FList.bosatsu

package ExistTest/FList                                                                                                                                                                                                                                                                                                         
                                                                                                                                                                                                                                                                                                                                
enum FList[a, b]:                                                                                                                                                                                                                                                                                                               
  Pure(fn: a -> b)                                                                                                                                                                                                                                                                                                              
  Cons(pair: exists c. ((a -> c), FList[c, b]))                                                                                                                                                                                                                                                                                 
                                                                                                                                                                                                                                                                                                                                
def cons[a, b, c](fn: a -> c, tail: FList[c, b]) -> FList[a, b]:                                                                                                                                                                                                                                                                
  Cons((fn, tail))                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                
def apply[a, b](fn: FList[a, b], a: a) -> b:                                                                                                                                                                                                                                                                                    
  recur fn:                                                                                                                                                                                                                                                                                                                     
    Pure(f): f(a)                                                                                                                                                                                                                                                                                                               
    Cons((f, tail)): apply(tail, f(a))                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                
def length_String(s: String) -> Int:                                                                                                                                                                                                                                                                                            
  def loop(s, acc):                                                                                                                                                                                                                                                                                                             
    recur s:                                                                                                                                                                                                                                                                                                                    
      case "": acc                                                                                                                                                                                                                                                                                                              
      case "$.{_}${tail}": loop(tail, acc.add(1))                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                
  loop(s, 0)                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                
flist = cons(int_to_String, Pure(length_String))                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                
res = flist.apply(523)                                                                                                                                                                                                                                                                                                          
test = Assertion(res matches 3, "523 is length 3")