Skip to content

cbart/flower

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 

Repository files navigation

Language description

flower is a purely functional language with strong static typing.

Data

flower provides following primitive data types

  • Int

    0 1 42 0x4f 0b0100 0o77
    
  • Float

    1.0 1.0e-19 0.001 6.022e+23
    
  • Bool

    true : Bool
    false : Bool
    
  • Char

    'a' 'x'
    

Additionally there are three type constructors given (all specified on every type - e.g. of kind *):

  • Maybe A which introduces possible lack of result

  • Stream A which specifies lazy data stream

  • Pair A B - a cartesian product or a 2-tuple

Built-in functions:

  • Int

    sum : Int -> Int -> Int
    sub : Int -> Int -> Int
    mul : Int -> Int -> Int
    quot : Int -> Int -> Maybe Int
    mod : Int -> Int -> Maybe Int
    neg : Int -> Int
    eq : Int -> Int -> Bool
    leq : Int -> Int -> Bool
    float : Int -> Float
    
  • Float

    sumf : Float -> Float -> Float
    subf : Float -> Float -> Float
    mulf : Float -> Float -> Float
    divf : Float -> Float -> Maybe Float
    negf : Float -> Float
    eqf : Float -> Float -> Bool
    leqf : Float -> Float -> Bool
    floor : Float -> Int
    ceil : Float -> Int
    
  • Bool

    and : Bool -> Bool -> Bool
    not : Bool -> Bool
    
  • Char

    upper : Char -> Char
    lower : Char -> Char
    

Data constructors for composed types:

  • Maybe A

    for A : *
    some : A -> Maybe A
    
    for A : *
    none : Maybe A
    
  • Stream A

    for A : *
    cons : A -> Stream A -> Stream A
    
    for A : *
    nil : Stream A
    
  • Pair A B

    for A : *, B : *
    pair : A -> B -> Pair A B
    

And following selectors/modifiers:

  • Maybe A

    for A : *, B : *
    maybe : (A -> B) -> B -> Maybe A -> B
    
  • Stream A

    for A : *
    head : Stream A -> Maybe A
    
    for A : *
    tail : Stream A -> Maybe (Stream A)
    
    for A : *, B : *
    stream : (A -> Stream A -> B) -> B -> Stream A -> B
    
  • Pair A B

    for A : *, B : *
    fst : Pair A B -> A
    
    for A : *, B : *
    snd : Pair A B -> B
    

Comments

# End of line comment
(# Delimited comment #)

Syntactic sugar

  • Not much of that (at the time being), but the following are equal:

    cons 'A' (cons 'S' (cons 'D' nil))
    
    "ASD"
    

Examples

Function composition

for A : *, B : *, C : *
let compose : (B -> C) -> (A -> B) -> (A -> C) =
  fun g f x ->
    g (f x)
  end

Fold

for A : *, B : *, C : *
let compose : (B -> C) -> (A -> B) -> (A -> C) =
  fun f g a -> f (g a) end


for E : *, R : *
let foldLeft : (R -> E -> R) -> R -> Stream E -> R =
  fun f acc ->
    stream
      (compose (foldLeft f) (f acc))
      acc
  end

Using the loop keyword (which refers to the inner most lambda):

for E : *, R : *
let foldLeft : (R -> E -> R) -> R -> Stream E -> R =
  fun f ->
    fun acc ->
      stream
        (compose loop (f acc))
        acc
    end
  end

QuickSort

# Examples of concat, gt or filter implementations
# can be found in `stdlib.fl`
let qSort : Stream Int -> Stream Int =
  stream
    fun h t ->
      concat
        (qSort (filter (leq h) t))
        (cons h (qSort (filter (gt h) t)))
    end
    nil

About

Pure functional programming language

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published