Find odd word which is not used with do

Odd word problem
You are encouraged to solve this task according to the task description, using any language you may know.

with Ada.Text_IO;
 
procedure Odd_Word_Problem is
 
   use Ada.Text_IO; -- Get, Put, and Look_Ahead
 
   function Current return Character is
      -- reads the current input character, without consuming it
      End_Of_Line: Boolean;
      C: Character;
   begin
      Look_Ahead(C, End_Of_Line);
      if End_Of_Line then
         raise Constraint_Error with "end of line before the terminating '.'";
      end if;
      return C;
   end Current;
 
   procedure Skip is
      -- consumes the current input character
      C: Character;
   begin
      Get(C);
   end Skip;
 
   function Is_Alpha(Ch: Character) return Boolean is
   begin
      return (Ch in  'a' .. 'z') or (Ch in 'A' .. 'Z');
   end Is_Alpha;
 
   procedure Odd_Word(C: Character) is
   begin
      if Is_Alpha(C) then
         Skip;
         Odd_Word(Current);
         Put(C);
      end if;
   end Odd_Word;
 
begin -- Odd_Word_Problem
   Put(Current);
   while Is_Alpha(Current) loop -- read an even word
      Skip;
      Put(Current);
   end loop;
   if Current /= '.' then -- read an odd word
      Skip;
      Odd_Word(Current);
      Put(Current);
      if Current /= '.' then -- read the remaining words
         Skip;
         Odd_Word_Problem;
      end if;
   end if;
end Odd_Word_Problem;

# recursively reverses the current word in the input and returns the    #
# the character that followed it                                        #
# "ch" should contain the first letter of the word on entry and will be #
# updated to the punctuation following the word on exit                 #
PROC reverse word = ( REF CHAR ch )VOID:
BEGIN

    CHAR    next ch;

    read( ( next ch ) );

    IF ( next ch <= "Z" AND next ch >= "A" )
    OR ( next ch <= "z" AND next ch >= "a" )
    THEN
        reverse word( next ch )
    FI;

    print( ( ch ) );

    ch := next ch

END; # reverse word #



# recursively prints the current word in the input and returns the      #
# character that followed it                                            #
# "ch" should contain the first letter of the word on entry and will be #
# updated to the punctuation following the word on exit                 #
PROC normal word = ( REF CHAR ch )VOID:
BEGIN

    print( ( ch ) );
    read ( ( ch ) );

    IF ( ch <= "Z" AND ch >= "A" )
    OR ( ch <= "z" AND ch >= "a" )
    THEN
        normal word( ch )
    FI

END; # normal word #



# read and print words and punctuation from the input stream, reversing #
# every second word                                                     #
PROC reverse every other word = VOID:
BEGIN

    CHAR ch;

    read( ( ch ) );

    WHILE
        ch /= "."
    DO
        normal word( ch );
        IF ch /= "."
        THEN
            print( ( ch ) );
            read ( ( ch ) );
            reverse word( ch )
        FI
    OD;

    print( ( ch ) )

END; # reverse every other word #



main: (
    reverse every other word
)

str := "what,is,the;meaning,of:life."
loop, parse, str
	if (A_LoopField ~= "[[:punct:]]")
		res .= A_LoopField, toggle:=!toggle
	else
		res := toggle ? RegExReplace(res, ".*[[:punct:]]K", A_LoopField ) : res A_LoopField
MsgBox % res

OPEN "/dev/stdin" FOR DEVICE AS in

FUNCTION get_odd()

    LOCAL ch, letter

    ch = MEMORY(1)
    GETBYTE ch FROM in

    IF NOT(REGEX(CHR$(PEEK(ch)), "[[:punct:]]")) THEN
        letter = get_odd()
        PRINT CHR$(PEEK(ch));
    ELSE
        letter = PEEK(ch)
    END IF

    FREE ch
    RETURN letter

END FUNCTION

mem = MEMORY(1)
PRINT "Enter string: ";

WHILE TRUE

    GETBYTE mem FROM in
    PRINT CHR$(PEEK(mem));

    IF REGEX(CHR$(PEEK(mem)), "[[:punct:]]") THEN
        IF PEEK(mem) <> 46 THEN
            POKE mem, get_odd()
            PRINT CHR$(PEEK(mem));
        END IF
        IF PEEK(mem) = 46 THEN BREAK
    END IF
WEND

FREE mem
CLOSE DEVICE in

PRINT

( ( odd-word
  =   dothis doother forward backward
    .   ( forward
        =   ch
          .   fil$:?ch
            & put$!ch
            & ( low$!ch:~<a:~>z&forward$
              | !ch:~"."
              )
        )
      & ( backward
        =   ch
          .   fil$:?ch
            & (   low$!ch:~<a:~>z
                & backward$() (put$!ch&)    { This reduces to the return value of backwards$()}
              | '(.put$($ch)&$ch:~".")      { Macro, evaluates to a function with actual ch.  }
              )
        )
      & fil$(!arg,r)
      &   ((=forward$).(=(backward$)$))
        : (?dothis.?doother)
      &   whl
        ' ( !(dothis.)
          & (!doother.!dothis):(?dothis.?doother)
          )
      & (fil$(,SET,-1)|)                 { This is how a file is closed: seek the impossible. }
  )
& put$("what,is,the;meaning,of:life.","life.txt",NEW)
& put$("we,are;not,in,kansas;any,more.","kansas.txt",NEW)
& odd-word$"life.txt"
& put$n
& odd-word$"kansas.txt"    { Real file, as Bracmat cannot read a single character from stdin. }
);

#include <stdio.h>
#include <ctype.h>

static int 
owp(int odd)
{
        int ch, ret;
        ch = getc(stdin);
        if (!odd) {
                putc(ch, stdout);
                if (ch == EOF || ch == '.')
                        return EOF;
                if (ispunct(ch))
                        return 0;
                owp(odd);
                return 0;
        } else {
                if (ispunct(ch))
                        return ch; 
                ret = owp(odd);
                putc(ch, stdout);
                return ret;
        }
}

int
main(int argc, char **argv)
{
        int ch = 1;
        while ((ch = owp(!ch)) != EOF) {
                if (ch)
                        putc(ch, stdout);
                if (ch == '.')
                        break;
        }
        return 0;
}

#include <iostream>
#include <cctype>
#include <functional>

using namespace std;

bool odd()
{
  function<void ()> prev = []{};
  while(true) {
    int c = cin.get();
    if (!isalpha(c)) {
      prev();
      cout.put(c);
      return c != '.';
    }
    prev = [=] { cout.put(c); prev();  };
  }
}

bool even() 
{
  while(true) {
    int c;
    cout.put(c = cin.get());
    if (!isalpha(c)) return c != '.';
  }
}


int main()
{
  bool e = false;
  while( e ? odd() : even() ) e = !e;
  return 0;
}

String[] meaning = ["what,", "is,", "the;", "meaning,", "of:", "life."];
String[] kansas = ["we,", "are,", "not,", "in,", "kansas;", "any,", "more."];

shared void run() {
    print("".join(reverseWords(meaning)));
    print("".join(reverseWords(kansas)));
}

String[] reverseWords(String[] words)
    => recursiveReverseWords(words, []);

String[] recursiveReverseWords(String[] remOrig, String[] revWords)
    => if (nonempty remOrig)
        then recursiveReverseWords(remOrig.rest,
                                   revWords.withTrailing(reverseWordRecursive(remOrig.first.sequence(),
                                                                              [],
                                                                              revWords.size.even)))
        else revWords;

String reverseWordRecursive(Character[] remOldChars, Character[] revChars, Boolean isEven)
    => if (nonempty remOldChars)
        then let (char = remOldChars.first) reverseWordRecursive(remOldChars.rest,
                                                                 conditionalAddChar(char, revChars, isEven),
                                                                 isEven)
        else String(revChars);

Character[] conditionalAddChar(Character char, Character[] chars, Boolean isEven)
    => if (isEven || isPunctuation(char))
        then chars.withTrailing(char)
        else chars.withLeading(char);

Boolean isPunctuation(Character char)
    => ",.:;".contains(char);

(defn next-char []
  (char (.read *in*)))

(defn forward []
  (let [ch (next-char)]
    (print ch)
    (if (Character/isLetter ch)
      (forward)
      (not= ch .))))

(defn backward []
  (let [ch (next-char)]
    (if (Character/isLetter ch)
      (let [result (backward)]
        (print ch)
        result)
      (fn [] (print ch) (not= ch .)))) )

(defn odd-word [s]
  (with-in-str s
    (loop [forward? true]
      (when (if forward?
              (forward)
              ((backward)))
        (recur (not forward?)))) )
    (println))

user=> (odd-word "what,is,the;meaning,of:life.")
what,si,the;gninaem,of:efil.
nil
user=> (odd-word "we,are;not,in,kansas;any,more.")
we,era;not,ni,kansas;yna,more.
nil

isWordChar = (c) -> /^w/.test c
isLastChar = (c) -> c is '.'

# Pass a function that returns an input character and one that outputs a
# character. JS platforms' ideas of single-character I/O vary widely, but this
# abstraction is adaptable to most or all.
oddWord = (get, put) ->
	forwardWord = ->
		loop
			# No magic here; buffer then immediately output.
			c = get()
			put(c)
			unless isWordChar(c)
				return not isLastChar(c)
	
	# NB: (->) is a CoffeeScript idiom for no-op.
	reverseWord = (outputPending = (->)) ->
		c = get()
		if isWordChar(c)
			# Continue word.
			# Tell recursive call to output this character, then any previously
			# pending characters, after the next word character, if any, has
			# been output.
			reverseWord ->
				put(c)
				outputPending()
		else
			# Word is done.
			# Output previously pending characters, then this punctuation.
			outputPending()
			put(c)
			return not isLastChar(c)
	
	# Alternate between forward and reverse until one or the other reports that
	# the end-of-input mark has been reached (causing a return of false).
	continue while forwardWord() and reverseWord()

isWordChar = (c) -> /^w/.test c
isLastChar = (c) -> c is '.'

oddWord = (get, put) ->
	forwardWord = ->
		loop
			c = get()
			put(c)
			unless isWordChar(c)
				return not isLastChar(c)
	
	reverseWord = (outputPending = (->)) ->
		c = get()
		if isWordChar(c)
			reverseWord ->
				put(c)
				outputPending()
		else
			outputPending()
			put(c)
			return not isLastChar(c)
	
	continue while forwardWord() and reverseWord()

# Redefine as necessary for target platform.
println = (z) -> console.log z

testData = [
	[
		"what,is,the;meaning,of:life."
		"what,si,the;gninaem,of:efil."
	]
	[
		"we,are;not,in,kansas;any,more."
		"we,era;not,ni,kansas;yna,more."
	]
]

results = for [testString, expectedResult] in testData
	# This test machinery uses string buffers for input and output. If your JS
	# platform sports single-character I/O, by all means, adapt to taste.
	getCursor = 0
	putBuffer = ""
	get = ->
		testString.charAt getCursor++
	put = (c) ->
		putBuffer += c
	oddWord(get,put)
	[testString, expectedResult, putBuffer, putBuffer is expectedResult]

println result for result in results

(defun odd-word (s)
  (let ((stream (make-string-input-stream s)))
    (loop for forwardp = t then (not forwardp)
          while (if forwardp
                    (forward stream)
                    (funcall (backward stream)))) ))

(defun forward (stream)
  (let ((ch (read-char stream)))
    (write-char ch)
    (if (alpha-char-p ch)
	(forward stream)
        (char/= ch #.))))

(defun backward (stream)
  (let ((ch (read-char stream)))
    (if (alpha-char-p ch)
        (prog1 (backward stream) (write-char ch))
        #'(lambda () (write-char ch) (char/= ch #.)))) )

? (odd-word "what,is,the;meaning,of:life.")
what,si,the;gninaem,of:efil.
NIL
? (odd-word "we,are;not,in,kansas;any,more.")
we,era;not,ni,kansas;yna,more.
NIL

bool doChar(in bool odd, in void delegate() nothrow f=null) nothrow {
    import core.stdc.stdio, std.ascii;

    immutable int c = getchar;
    if (!odd)
        c.putchar;
    if (c.isAlpha)
        return doChar(odd, { c.putchar; if (f) f(); });
    if (odd) {
        if (f) f();
        c.putchar;
    }
    return c != '.';
}

void main() {
    bool i = true;
    while (doChar(i = !i)) {}
}

program Odd_word_problem;

{$APPTYPE CONSOLE}

uses
  System.SysUtils,
  System.Console,
  System.Character;

function doChar(isOdd: boolean; f: TProc = nil): Boolean;
begin
  var c: char := Console.ReadKey(True).KeyChar;

  if not isOdd then
    Write(c);

  if c.IsLetter then
    exit(doChar(isOdd,
      procedure
      begin
        Write(c);
        if assigned(f) then
          f();
      end));

  if isOdd then
  begin
    if Assigned(f) then
      f();
    write(c);
  end;

  exit(c <> '.');

end;

begin
  var i: boolean := false;
  while doChar(i) do
    i := not i;
  readln;
end.

(lib 'sequences)
(define input-stream null)
(define output-stream "")

;;---------------------------
;; character I/O simulation
;; --------------------------
(define (read-char) (next input-stream)) ;; #f if EOF
(define (write-char c) (when c (set! output-stream (string-append output-stream c))))

(define (init-streams sentence)
	(set! input-stream (procrastinator sentence))
	(set! output-stream ""))

;;---------------------------------
;; task , using read-char/write-char
;;----------------------------------

(define (flop) ; reverses,  and returns first non-alpha after word, or EOF
	(define c (read-char))
	(if (string-alphabetic? c) (begin0 (flop) (write-char c)) c))
	  
(define (flip)
    (define c (read-char))
    (if (string-alphabetic? c) (begin (write-char c)  (flip)) c))
    
(define (task sentence)
	 (init-streams sentence)
	 (while (and (write-char (flip)) (write-char (flop))))
	 output-stream )

(task "what,is,the;meaning,of:life.")
    → "what,si,the;gninaem,of:efil."
; check diacritical
(task "Longtemps,je me suis couché,héhé,hôhô,de bonne heure.")
    → "Longtemps,ej me sius couché,éhéh,hôhô,ed bonne erueh."

defmodule Odd_word do
  def handle(s, false, i, o) when ((s >= "a" and s <= "z") or (s >= "A" and s <= "Z")) do
    o.(s)
    handle(i.(), false, i, o)
  end
  def handle(s, t, i, o) when ((s >= "a" and s <= "z") or (s >= "A" and s <= "Z")) do
    d = handle(i.(), :rec, i, o)
    o.(s)
    if t == true, do: handle(d, t, i, o), else: d
  end
  def handle(s, :rec, _, _), do: s
  def handle(?., _, _, o), do: o.(?.); :done 
  def handle(:eof, _, _, _), do: :done
  def handle(s, t, i, o) do
    o.(s)
    handle(i.(), not t, i, o)
  end
  
  def main do
    i = fn() -> IO.getn("") end
    o = fn(s) -> IO.write(s) end
    handle(i.(), false, i, o)
  end
end

Odd_word.main

handle(S, false, I, O) when (((S >= $a) and (S =< $z)) or ((S >= $A) and (S =< $Z))) ->
    O(S),
    handle(I(), false, I, O);
handle(S, T, I, O) when (((S >= $a) and (S =< $z)) or ((S >= $A) and (S =< $Z))) ->
    D = handle(I(), rec, I, O),
    O(S),
    case T of true -> handle(D, T, I, O); _ -> D end;
handle(S, rec, _, _) -> S;
handle($., _, _, O) -> O($.), done; 
handle(eof, _, _, _) -> done;
handle(S, T, I, O) -> O(S), handle(I(), not T, I, O).

main([]) ->
    I = fun() -> hd(io:get_chars([], 1)) end,
    O = fun(S) -> io:put_chars([S]) end,
    handle(I(), false, I, O).

open System
open System.Text.RegularExpressions

let mutable Inp = Console.In

let Out c = printf "%c" c; (if c = '.' then Environment.Exit 0)

let In() = Inp.Read() |> Convert.ToChar

let (|WordCharacter|OtherCharacter|) c =
    if Regex.IsMatch(c.ToString(),"[a-zA-Z]") then
        WordCharacter
    else
        OtherCharacter

let rec forward () =
    let c = In()
    let rec backward () : char =
        let c = In()
        match c with
        | WordCharacter ->
            let s = backward() in Out c; s
        | OtherCharacter -> c
    Out c
    match c with
    | WordCharacter -> forward()
    | OtherCharacter -> backward() 

[<EntryPoint>]
let main argv =
    if argv.Length > 0 then Inp <- new System.IO.StringReader(argv.[0])
    let rec loop () = forward() |> Out;  loop()
    loop()
    0

USING: continuations kernel io io.streams.string locals unicode.categories ;
IN: rosetta.odd-word

<PRIVATE
! Save current continuation.
: savecc ( -- continuation/f )
    [ ] callcc1 ; inline

! Jump back to continuation, where savecc will return f.
: jump-back ( continuation -- )
    f swap continue-with ; inline
PRIVATE>

:: read-odd-word ( -- )
    f :> first-continuation!
    f :> last-continuation!
    f :> reverse!
    ! Read characters. Loop until end of stream.
    [ read1 dup ] [
        dup Letter? [
            ! This character is a letter.
            reverse [
                ! Odd word: Write letters in reverse order.
                last-continuation savecc dup [
                    last-continuation!
                    2drop       ! Drop letter and previous continuation.
                ] [
                    ! After jump: print letters in reverse.
                    drop                ! Drop f.
                    swap write1         ! Write letter.
                    jump-back           ! Follow chain of continuations.
                ] if
            ] [
                ! Even word: Write letters immediately.
                write1
            ] if
        ] [
            ! This character is punctuation.
            reverse [
                ! End odd word. Fix trampoline, follow chain of continuations
                ! (to print letters in reverse), then bounce off trampoline.
                savecc dup [
                    first-continuation!
                    last-continuation jump-back
                ] [ drop ] if
                write1                  ! Write punctuation.
                f reverse!              ! Begin even word.
            ] [
                write1                  ! Write punctuation.
                t reverse!              ! Begin odd word.
                ! Create trampoline to bounce to (future) first-continuation.
                savecc dup [
                    last-continuation!
                ] [ drop first-continuation jump-back ] if
            ] if
        ] if
    ] while
    ! Drop f from read1. Then print a cosmetic newline.
    drop nl ;

: odd-word ( string -- )
    [ read-odd-word ] with-string-reader ;

[$$$$'.=',=|';=|':=|~[^s;!,]?]s:              {recursive reading}
[s;!$'.=~[,^f;!]?]r:                              {reverse words}
[[$$$$'.=',=|';=|':=|~][,^]#$'.=~[,^r;!]?]f:   {forward words}
^f;!,                                             {start}

: word?  dup [char] . <> over bl <> and ;
: ?quit  dup [char] . = if emit quit then ;
: eatbl  begin dup bl = while drop key repeat ?quit ;
: even   begin word? while emit key repeat ;
: odd    word? if key recurse swap emit then ;
: main   cr key eatbl begin even eatbl space odd eatbl space again ;

      MODULE ELUDOM	!Uses the call stack for auxiliary storage.
       INTEGER MSG,INF	!I/O unit numbers.
       LOGICAL DEFER	!To stumble, or not to stumble.
       CONTAINS
        CHARACTER*1 RECURSIVE FUNCTION GET(IN)	!Returns one character, going forwards.
         INTEGER IN	!The input file.
         CHARACTER*1 C	!The single character to be read therefrom.
          READ (IN,1,ADVANCE="NO",EOR=3,END=4) C	!Thus. Not advancing to the next record.
    1     FORMAT (A1,$)	!For output, no advance to the next line either.
    2     IF (("A"<=C .AND. C<="Z").OR.("a"<=C .AND. C<="z")) THEN	!Unsafe for EBCDIC.
            IF (DEFER) THEN	!Are we to reverse the current text?
              GET = GET(IN)	!Yes. Go for the next letter.
              WRITE (MSG,1) C	!And now, backing out, reveal the letter at this level.
              RETURN		!Retreat another level.
            END IF		!Thus passing back the ending non-letter that was encountered.
           ELSE		!And if we've encountered a non-letter,
            DEFER = .NOT. DEFER	!Then our backwardness flips.
          END IF	!Enough inspection of C.
    3     GET = C	!Pass it back.
          RETURN	!And we're done.
    4     GET = CHAR(0)	!Reserving this for end-of-file.
        END FUNCTION GET!That was strange.
      END MODULE ELUDOM	!But as per the specification.

      PROGRAM CONFUSED	!Just so.
      USE ELUDOM	!Forwards? Backwards?
      CHARACTER*1 C	!A scratchpad for multiple inspections.
      MSG = 6	!Standard output.
      INF = 10	!This will do.
      OPEN (INF,NAME = "Confused.txt",STATUS="OLD",ACTION="READ")	!Go for the file.

Chew through the input. A full stop marks the end.
   10 DEFER = .FALSE.	!Start off going forwards.
   11 C = GET(INF)		!Get some character from file INF.
      IF (ICHAR(C).LE.0) STOP		!Perhaps end-of-file is reported.
      IF (C.NE." ") WRITE (MSG,12) C	!Otherwise, write it. A blank for end-of-record.
   12 FORMAT (A1,$)			!Obviously, not finishing the line each time.
      IF (C.NE.".") GO TO 11	!And if not a full stop, do it again.
      WRITE (MSG,"('')")	!End the line of output.
      GO TO 10		!And have another go.
      END	!That was confusing.

package main

import (
    "bytes"
    "fmt"
    "io"
    "os"
    "unicode"
)

func main() {
    owp(os.Stdout, bytes.NewBufferString("what,is,the;meaning,of:life."))
    fmt.Println()
    owp(os.Stdout, bytes.NewBufferString("we,are;not,in,kansas;any,more."))
    fmt.Println()
}

func owp(dst io.Writer, src io.Reader) {
    byte_in := func () byte {
        bs := make([]byte, 1)
        src.Read(bs)
        return bs[0]
    }
    byte_out := func (b byte) { dst.Write([]byte{b}) }    
    var odd func() byte
    odd = func() byte {
        s := byte_in()
        if unicode.IsPunct(rune(s)) {
            return s
        }
        b := odd()
        byte_out(s)
        return b
    }
    for {
        for {
            b := byte_in()
            byte_out(b)
            if b == '.' {
                return
            }
            if unicode.IsPunct(rune(b)) {
                break
            }
        }
        b := odd()
        byte_out(b)
        if b == '.' {
            return
        }
    }
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "os"
    "unicode"
)

func main() {
    owp(os.Stdout, bytes.NewBufferString("what,is,the;meaning,of:life."))
    fmt.Println()
    owp(os.Stdout, bytes.NewBufferString("we,are;not,in,kansas;any,more."))
    fmt.Println()
}

func owp(dst io.Writer, src io.Reader) {
    byte_in := func () byte {
        bs := make([]byte, 1)
        src.Read(bs)
        return bs[0]
    }
    byte_out := func (b byte) { dst.Write([]byte{b}) }    
    odd := func() byte {
        for {
            b := byte_in()
            if unicode.IsPunct(int(b)) {
                return b
            }
            defer byte_out(b)
        }
        panic("impossible")
    }
    for {
        for {
            b := byte_in()
            byte_out(b)
            if b == '.' {
                return
            }
            if unicode.IsPunct(rune(b)) {
                break
            }
        }
        b := odd()
        byte_out(b)
        if b == '.' {
            return
        }
    }
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "os"
    "unicode"
)

func main() {
    owp(os.Stdout, bytes.NewBufferString("what,is,the;meaning,of:life."))
    fmt.Println()
    owp(os.Stdout, bytes.NewBufferString("we,are;not,in,kansas;any,more."))
    fmt.Println()
}

type Coroutine struct {
    out <-chan Coroutine
    in chan<- byte
}

func owp(dst io.Writer, src io.Reader) {
    byte_in := func () (byte, error) {
        bs := make([]byte, 1)
        _, err := src.Read(bs)
        return bs[0], err
    }
    byte_out := func (b byte) { dst.Write([]byte{b}) }    

    var f, r Coroutine

    f = func () Coroutine {
        out := make(chan Coroutine)
	in := make(chan byte)
        var fwd func (byte) byte
        fwd = func (c byte) (z byte) {
            if unicode.IsLetter(rune(c)) {
                byte_out(c)
                out <- f
                z = fwd(<- in)
            } else {
                z = c
            }
            return
        }
        go func () {
            for {
                x, ok := <- in
                if !ok { break }
                byte_out(fwd(x))
                out <- r
            }
        } ()
        return Coroutine{ out, in }
    } ()
    r = func () Coroutine {
        out := make(chan Coroutine)
	in := make(chan byte)
        var rev func (byte) byte
        rev = func (c byte) (z byte) {
            if unicode.IsLetter(rune(c)) {
                out <- r
                z = rev(<- in)
                byte_out(c)
            } else {
                z = c
            }
            return
        }
        go func () {
            for {
                x, ok := <- in
                if !ok { break }
                byte_out(rev(x))
                out <- f
            }
        } ()
        return Coroutine{ out, in }
    } ()

    for coro := f; ; coro = <- coro.out {
        c, err := byte_in()
        if err != nil { break }
        coro.in <- c
    }
    close(f.in)
    close(r.in)
}

import System.IO
       (BufferMode(..), getContents, hSetBuffering, stdin, stdout)
import Data.Char (isAlpha)

split :: String -> (String, String)
split = span isAlpha

parse :: String -> String
parse [] = []
parse l =
  let (a, w) = split l
      (b, x) = splitAt 1 w
      (c, y) = split x
      (d, z) = splitAt 1 y
  in a <> b <> reverse c <> d <> parse z

main :: IO ()
main =
  hSetBuffering stdin NoBuffering >> hSetBuffering stdout NoBuffering >> getContents >>=
  putStr . takeWhile (/= '.') . parse >>
  putStrLn "."

isAlpha :: Char -> Bool
isAlpha = flip elem $ ['a'..'z'] ++ ['A'..'Z']

parse :: IO ()
parse = do
  x <- getChar
  putChar x
  case () of
   _ | x == '.'  -> return ()
     | isAlpha x -> parse
     | otherwise -> do
         c <- revParse
         putChar c
         if c == '.'
           then return ()
           else parse

revParse :: IO Char
revParse = do
  x <- getChar
  case () of
   _ | x == '.'  -> return x
     | isAlpha x -> do
         c <- revParse
         putChar x
         return c
     | otherwise -> return x

main :: IO ()
main = hSetBuffering stdin NoBuffering >> hSetBuffering stdout NoBuffering >>
       parse >> putStrLn ""

procedure main()
every OddWord(!["what,is,the;meaning,of:life.", 
                "we,are;not,in,kansas;any,more."])
end

procedure OddWord(stream)                     #: wrapper for demonstration
   write("Input stream: ",stream)
   writes("Output stream: ") & eWord(create !stream,'.,;:') & write()
end
    
procedure eWord(stream,marks)                 #: handle even words
   repeat {                               
      repeat 
         writes(@stream) ? if ="." then return else if any(marks) then break
      if writes(oWord(stream,marks)) == '.' then return
      }
end

procedure oWord(stream,marks)                 #: handle odd words (reverse)   
   if any(marks,s := @stream) then return s
   return 1(oWord(stream,marks), writes(s))  
end

procedure main(A)
    repeat (while writes((any(&letters, c := reads(&input,1)),c))) |
           (writes(c) ~== "." ~== writes(rWord())) | break write()
end

procedure rWord(c)
    c1 := rWord((any(&letters, c1 := reads(&input,1)),c1))
    writes(c)
    return c1
end

putch=: 4 :0                 NB. coroutine verb
  outch y
  return x
)

isletter=: toupper ~: tolower

do_char=: 3 :0                 NB. coroutine verb
  ch=. getch''
  if. isletter ch do.
    if. odd do.
      putch&ch yield do_char '' return.
    end.
  else.
    odd=: -. odd
  end.
  return ch
)

evenodd=: 3 :0
  clear_outstream begin_instream y
  odd=: 0
  whilst. '.'~:char do.
    outch char=. do_char coroutine ''
  end.
)

   evenodd 'what,is,the;meaning,of:life.'
what,si,the;gninaem,of:efil.
   evenodd 'we,are;not,in,kansas;any,more.'
we,era;not,ni,kansas;yna,more.

public class OddWord {
    interface CharHandler {
	CharHandler handle(char c) throws Exception;
    }
    final CharHandler fwd = new CharHandler() {
	public CharHandler handle(char c) {
	    System.out.print(c);
	    return (Character.isLetter(c) ? fwd : rev);
	}
    };
    class Reverser extends Thread implements CharHandler {
	Reverser() {
	    setDaemon(true);
	    start();
	}
	private Character ch; // For inter-thread comms
	private char recur() throws Exception {
	    notify();
	    while (ch == null) wait();
	    char c = ch, ret = c;
	    ch = null;
	    if (Character.isLetter(c)) {
		ret = recur();
		System.out.print(c);
	    }
	    return ret;
	}
	public synchronized void run() {
	    try {
		while (true) {
		    System.out.print(recur());
		    notify();
		}
	    } catch (Exception e) {}
	}
	public synchronized CharHandler handle(char c) throws Exception {
	    while (ch != null) wait();
	    ch = c;
	    notify();
	    while (ch != null) wait();
	    return (Character.isLetter(c) ? rev : fwd);
	}
    }
    final CharHandler rev = new Reverser();

    public void loop() throws Exception {
	CharHandler handler = fwd;
	int c;
	while ((c = System.in.read()) >= 0) {
	    handler = handler.handle((char) c);
	}
    }

    public static void main(String[] args) throws Exception {
	new OddWord().loop();
    }
}

# io = readstring(STDIN)
io = "what,is,the;meaning,of:life."
i  = 0

readbyte!() = io[global i += 1]
writebyte(c) = print(Char(c))

function odd(prev::Function = () -> false)
    a = readbyte!()
    if !isalpha(a)
        prev()
        writebyte(a)
        return a != '.'
    end

    # delay action until later, in the shape of a closure
    clos() = (writebyte(a); prev())

    return odd(clos)
end

function even()
    while true
        c = readbyte!()
        writebyte(c)
        if !isalpha(c) return c != '.' end
    end
end

evn = false
while evn ? odd() : even()
    evn = !evn
end

// version 1.1.3

typealias Func = () -> Unit

fun doChar(odd: Boolean, f: Func?): Boolean {
    val c = System.`in`.read()
    if (c == -1) return false // end of stream reached
    val ch = c.toChar()

    fun writeOut() {
        print(ch)
        if (f != null) f()
    }

    if (!odd) print(ch)
    if (ch.isLetter()) return doChar(odd, ::writeOut)
    if (odd) {
        if (f != null) f()
        print(ch)
    } 
    return ch != '.'
}

fun main(args: Array<String>) {
    repeat(2) {
        var b = true
        while (doChar(!b, null)) b = !b
        System.`in`.read() // remove 'n' from buffer
        println("n")        
    }
}

define odd_word_processor(str::string) => {
	local(
		isodd 		= false,
		pos 		= 1,
		invpos	 	= 1,
		lastpos		= 1
	)
	while(#str->get(#pos) != '.' && #pos <= #str->size) => {
		if(not #str->isAlpha(#pos)) => {
			not #isodd ? #isodd = true | #isodd = false	
		}
		if(#isodd) => {
			#lastpos = 1
			#invpos = 1
			while(#str->isAlpha(#pos+#lastpos) && #pos+#lastpos <= #str->size) => {
				#lastpos++
			}
			'odd lastpos: '+#lastpos+'r'
			local(maxpos = #pos+#lastpos-1)
			while(#invpos < (#lastpos+1)/2) => {
				local(i,o,ipos,opos)
				#ipos = #pos+#invpos
				#opos = #pos+(#lastpos-#invpos)
				#i = #str->get(#ipos)
				#o = #str->get(#opos)
				
				//'switching '+#i+' and '+#o+'r'
				
				//'insert '+#o+' at '+(#ipos)+'r'
				#str = string_insert(#str,-position=(#ipos),-text=#o)
	
				//'remove redundant pos '+(#ipos+1)+'r'
				#str->remove(#ipos+1,1)
				
				//'insert '+#i+' at '+(#opos)+'r'
				#str = string_insert(#str,-position=(#opos),-text=#i)
	
				//'remove redundant pos '+(#opos+1)+'r'
				#str->remove(#opos+1,1)
				
				#invpos++
			}
			#pos += #lastpos - 1
		}
		//#str->get(#pos) + #isodd + 'r'
		#pos += 1
	}
	return #str
}

'orig:rwhat,is,the;meaning,of:life.r'
'new:r'
odd_word_processor('what,is,the;meaning,of:life.')
'rShould have:rwhat,si,the;gninaem,of:efil.'

function reverse()
  local ch = io.read(1)
  if ch:find("%w") then
    local rc = reverse()
    io.write(ch)
    return rc
  end
  return ch
end

function forward()
  ch = io.read(1)
  io.write(ch)
  if ch == "." then return false end
  if not ch:find("%w") then
    ch = reverse()
    if ch then io.write(ch) end
    if ch == "." then return false end
  end
  return true
end

while forward() do end

Module Checkit {
       global out$
       document out$
      Function PrepareStream$ (buf$) {
            \ get a temporary file 
            if buf$="" then {
                  class ref {
                         f
                  class:
                        module ref (.f) { }
                  }
                  \ make f closure by reference
                  m->ref(false)
                  =lambda$  m->{
                        if m=>f then exit
                        r$=Key$
                        m=>f=r$="."
                        =r$
                  }
                  \ exit function
                  break
            }
            name$=tempname$
            \ we use Ansi type files
            Open name$ for output as F
                  Print #F, buf$;
            Close #F
            Open name$ for input as #f
            class ref {
                   f
            class:
                  module ref (.f) { }
            }
            \ make f closure by reference
            m->ref(f)
            =lambda$ m -> {
                  if m=>f=-1000 then exit
                  def r$
                  if not eof(#m=>f) then  r$=Input$(#m=>f,2)
                  =r$
                  if r$="" or r$="." then close #m=>f : m=>f=-1000 
            }
      }
      Module Odd(c$) {
            one$=""
            Module MyEven(c$, &last$) {
                 one$=If$(last$=""->c$(), last$)
                 if one$="" then exit
                 if not one$ ~"[a-zA-Z]" Then last$=one$: exit
                 \ print before
                 Print one$; 
                 out$<=one$
                 Call MyEven, c$, &last$
            }
            Module MyOdd(c$, &last$) {
                 one$=If$(last$=""->c$(), last$)
                 if one$="" then exit
                 if not one$ ~"[a-zA-Z]" Then last$=one$: exit
                 Call MyOdd, c$, &last$
                 \ print after
                 Print one$; 
                  out$<=one$
            }
            Do {
                  one$=""
                  Call MyEven, c$, &one$
                  if one$="" then exit
                  Print one$;
                  out$<=one$
                  one$=""
                  Call MyOdd, c$, &one$
                  if one$="" then exit
                  Print one$;
                  out$<=one$
            }   Always
            Print
            out$<={
            }
      }
      \ Feeding keyboard
      keyboard "what,is,the;meaning,of:life."
      Odd PrepareStream$("")
      \ Use a file for input
      Odd PrepareStream$("we,are;not,in,kansas;any,more.")
      clipboard out$
}
Checkit

Module OddWord {
      k$=lambda$->""
      state=false
      odd=True
      do {
            a$=key$
            if a$ ~"[a-zA-Z]" then {
                  If state Else state~ : odd~
                  if state and odd then k$=lambda$ k$, a$->a$+k$() : Continue
                  Print a$;
            } Else {
                  If state Then state~
                  if odd then Print k$(); : k$=lambda$->""
                  Print a$;      
            }
      } until a$="."
      Print
}
keyboard "what,is,the;meaning,of:life."
OddWord
Keyboard "we,are;not,in,kansas;any,more."
OddWord

import unicode

type Proc = proc(): bool {.closure.}

var nothing: Proc = proc(): bool {.closure.} = false

proc odd(prev = nothing): bool =
  let a = stdin.readChar()
  if not isAlpha(Rune(ord(a))):
    discard prev()
    stdout.write(a)
    return a != '.'

  # delay action until later, in the shape of a closure
  proc clos(): bool =
    stdout.write(a)
    prev()

  return odd(clos)

proc even(): bool =
  while true:
    let c = stdin.readChar()
    stdout.write(c)
    if not isAlpha(Rune(ord(c))):
      return c != '.'

var e = false
while (if e: odd() else: even()):
  e = not e

import strutils

proc reverseWord(ch: var char) =
  var nextch = stdin.readChar()
  if nextch.isAlphaAscii():
    reverseWord(nextch)
  stdout.write(ch)
  ch = nextch

proc normalWord(ch: var char) =
  stdout.write(ch)
  ch = stdin.readChar()
  if ch.isAlphaAscii():
    normalWord(ch)

var ch = stdin.readChar()

while ch != '.':
  normalWord(ch)
  if ch != '.':
    stdout.write(ch)
    ch = stdin.readChar()
    reverseWord(ch)
stdout.write(ch)

let is_alpha c =
  c >= 'a' && c <= 'z' ||
  c >= 'A' && c <= 'Z'

let rec odd () =
  let c = input_char stdin in
  if is_alpha c
  then (let e = odd () in print_char c; e)
  else (c)

let rec even () =
  let c = input_char stdin in
  if is_alpha c
  then (print_char c; even ())
  else print_char c

let rev_odd_words () =
  while true do
    even ();
    print_char (odd ())
  done

let () =
  try rev_odd_words ()
  with End_of_file -> ()

(define (odd_word_problem words)
   (letrec ((odd (lambda (s out)
               (let loop ((s s) (l '()))
                  (cond
                     ((null? s)
                        out)
                     ((pair? s)
                        (if (<= #a (car s) #z)
                           (loop (cdr s) (cons (car s) l))
                           (even (cdr s) (cons (cons (reverse l) (car s)) out))))
                     (else
                        (loop (s) l))))))
            (even (lambda (s out)
               (let loop ((s s) (l '()))
                  (cond
                     ((null? s)
                        out)
                     ((pair? s)
                        (if (<= #a (car s) #z)
                           (loop (cdr s) (cons (car s) l))
                           (odd (cdr s) (cons (cons l (car s)) out))))
                     (else
                        (loop (s) l)))))))
      (for-each (lambda (p)
                  (display (runes->string (car p)))
                  (display (string (cdr p))))
         (reverse
            (odd (str-iter words) '()))))
      (print))
(odd_word_problem "what,is,the;meaning,of:life.")
(odd_word_problem "we,are;not,in,kansas;any,more.")