fancy 0.3.0

data/examples/argv.fy

@@ -0,0 +1,8 @@
+# argv.fy
+# Example of fancy's interface for command line arguments
+
+"This will always get printed, even when required from another file" println
+
+if: (ARGV[0] == __FILE__) then: {
+  "This will get printed, if this file is directly run with fancy" println
+}

data/examples/arithmetic.fy

@@ -0,0 +1,7 @@
+# arithmetic.fy
+# Example of some basic arithmetic operations in fancy
+
+23 + 32432.32 println
+324432.432 - 32432.4324 println
+32432 * 432.32 println
+432 / 12319 println

data/examples/armstrong_numbers.fy

@@ -0,0 +1,33 @@
+# armstrong_numbers.fy
+# Calculates & outputs all Armstrong Numbers between 0 and 10000.
+# See http://en.wikipedia.org/wiki/Narcissistic_number for more
+# information.
+
+class Fixnum {
+  def decimals {
+    """Returns all decimals of a Number as an Array.
+      E.g. 123 decimals # => [1,2,3]"""
+
+    decimals = []
+    tmp = self
+    while: { tmp >= 10 } do: {
+      decimals << (tmp modulo: 10)
+      tmp = (tmp div: 10)
+    }
+    decimals << tmp
+    decimals
+  }
+
+  def armstrong? {
+    "Indicates, if a Number is a Armstrong Number."
+
+    decimals = self decimals
+    n_decimals = decimals size
+    decimals map: |x| { x ** n_decimals } . sum == self
+  }
+}
+
+# output alls Armstrong Numbers between 0 and 10000
+0 upto: 10000 do_each: |i| {
+  { i println } if: $ i armstrong?
+}

data/examples/array.fy

@@ -0,0 +1,52 @@
+# array.fy
+# Examples of fancy Arrays
+
+# create an array
+arr = [1,2,3,4,5,6]
+
+# print each element squared
+arr each: |x| {
+  x squared println
+}
+
+# display each element with its index in the array
+arr each_with_index: |x i| {
+  "Index " ++ i ++ " -> " ++ x println
+}
+
+# print the array of squared elements
+arr map: 'squared . inspect println
+
+# print the array of doubled elements
+arr map: 'doubled . inspect println
+
+# print array of all elements smaller than 4
+arr select: |x| { x < 4 } . inspect println
+
+# print array of all elements that are not smaller than 4
+arr reject: |x| { x < 4 } . inspect println
+
+# prints: [5, 6]
+arr take_while: |x| { x < 5 } . inspect println
+
+"testing reduce:init_val: " print
+arr reduce: |acc x| { acc * x } init_val: 1 . println # same as: 1*1*2*3*4*5*6
+
+"testing any?: " print
+arr any?: |x| { x > 3 } . println # prints: true
+
+"testing all?: " print
+arr all?: |x| { x < 7 } . println # prints: true
+
+"testing from:to: " print
+arr [[3,5]] . inspect println # prints: [4, 5, 6]
+
+# some other handy methods
+"testing size: " print
+arr size println # prints: 6
+
+"testing to_s: " print
+arr to_s println # prints: 123456
+
+"testing inspect: " print
+arr inspect println # prints: [1, 2, 3, 4, 5, 6] : Array

data/examples/blocks.fy

@@ -0,0 +1,15 @@
+# blocks.fy
+# Examples of fancy code blocks
+
+x = { Console println: "Println from within block!" }
+x call # calls x and prints: "Println from within block!"
+
+y = |x y| { Console println: $ x + y }
+y call: [2, 3] # calls y and prints: 5
+
+# prints numbers 0 to 20
+zahl = 0
+while: { zahl <= 20 } do: {
+  Console println: zahl
+  zahl = zahl + 1
+}

data/examples/boolean.fy

@@ -0,0 +1,24 @@
+# boolean.fy
+# Example of boolean expressions and logical operations in fancy
+
+true and: true . println # true
+true and: nil . println # nil
+nil and: nil . println # nil
+
+true or: true . println # true
+true or: nil . println # true
+nil or: nil . println # nil
+
+
+"--------------" println
+
+# won't print string
+nil if_true: {
+  "this should _not_ be displayed" println
+}
+
+# will print string
+nil if_false: {
+  "this _should_ be displayed" println
+}
+

data/examples/call_with_receiver.fy

@@ -0,0 +1,9 @@
+block = { self foo }
+
+class Foo {
+  def foo {
+    "in Foo#foo!" println
+  }
+}
+
+block call_with_receiver: (Foo new)

data/examples/class.fy

@@ -0,0 +1,68 @@
+# class.fy
+# Example of fancy's classes mechanism
+
+class Bar {
+  def initialize {
+    Console println: "In Bar constructor!"
+  }
+
+  def say_hello: name {
+    Console print: "Hello, "
+    Console println: name
+  }
+}
+
+class Foo : Bar {
+  def initialize: name {
+    Console println: "gonna set @name"
+    @name = name
+  }
+  def say_hello {
+    Console print: "Hello, "
+    Console println: @name
+    {@block call} if: @block
+  }
+  def on_hello_do: block {
+    @block = block
+  }
+}
+
+bar = Bar new
+bar say_hello: "Chris"
+
+foo = Foo new: "Chris from Constructor"
+foo say_hello
+foo on_hello_do: {
+  Console println: "Call me when calling on_hello! :)"
+}
+foo say_hello
+
+foo class println # print the class of foo
+
+# define a singleton method on foo object
+foo define_singleton_method: "foo!" with: {
+  "In foo method :D" println
+}
+
+foo foo!
+
+# define a 'normal' method on Foo class
+# (instance method for all instances of Foo)
+foo class define_method: "foo_for_all:" with: |x| {
+  "In foo_for_all method (defined for all instances of Foo class)" println
+  "Got argument: " ++ x println
+}
+
+foo2 = Foo new
+foo2 foo_for_all: "hello, test! :)"
+foo  foo_for_all: "hello, test (again)! :)"
+
+# define a class method on Foo class
+# it's the same as calling 'define_singleton_method:with:' on class
+foo class define_class_method: "cool_class_method:" with: |arg| {
+  "In class method for Foo! Argument given: " ++ arg println
+}
+
+# the following is the same as:
+# foo class cool_class_method: "Some argument string"
+Foo cool_class_method: "Some argument string"

data/examples/closures.fy

@@ -0,0 +1,24 @@
+# closure.fy
+# Example of closures in fancy
+
+# method that returns a closure
+def create_counter: number {
+  closure = {
+    number = number + 1
+  }
+  closure
+}
+
+# create a counter from 100 upwards
+closure = create_counter: 100
+# this will print numbers 100 - 120
+20 times: {
+  Console println: $ closure call
+}
+
+# create a counter from 500 upwards
+closure = create_counter: 500
+# this will print numbers 500 - 510
+10 times: {
+  Console println: $ closure call
+}

data/examples/constant_access.fy

@@ -0,0 +1,15 @@
+class Foo {
+ class Bar {
+   def self name { 'bar }
+ }
+}
+
+Foo Bar name println
+
+class Foo Baz {  }
+
+Foo Baz == Foo::Baz println
+
+def Foo Baz name { 'baz }
+
+Foo Baz name println

data/examples/default_args.fy

@@ -0,0 +1,17 @@
+# default_args.fy
+# Example of fancy's default arguments
+
+def arg1: arg1 arg2: arg2 ("default_arg2") arg3: arg3 ("default_arg3") {
+  "arguments are: " println
+  arg1 println
+  arg2 println
+  arg3 println
+}
+
+arg1: "hello" arg2: "world" arg3: "how are you?"
+
+Console newline
+arg1: "hello" arg2: "world"
+
+Console newline
+arg1: "hello"

data/examples/define_methods.fy

@@ -0,0 +1,15 @@
+arr = [1,2,3]
+arr define_singleton_method: "foo" with: {
+  "in foo!" println
+  self inspect println
+}
+
+arr send: 'foo
+
+arr undefine_singleton_method: "foo"
+
+try {
+  arr send: 'foo
+} catch NoMethodError => e {
+  e println
+}

data/examples/documentation.fy

@@ -0,0 +1,57 @@
+# documentation.fy
+# Example about fancys built-in documentation facilities
+
+class Foo {
+
+  """
+  If first expression in a class body is an string literal
+  it is used as documentation.
+  """
+
+  m = def foo: x bar: y (22) {
+    "Prints its own documentation."
+    "TODO: obtain methodContext and print own documentation" println
+  }
+  m documentation println
+
+}
+
+foo = Foo new
+
+foo method: 'foo:bar: . documentation println
+foo method: 'foo: . documentation println
+
+def foo bar: n {
+   "A singleton method"
+   n println
+}
+
+foo method: 'bar: . documentation println
+
+Foo instance_method: 'foo: . documentation println
+
+Foo documentation println
+
+block = |a, b| {
+  "A block can also have a documentation string, just like methods"
+  a + b
+}
+
+block documentation println
+
+
+Math PI documentation: "An aproximation of the PI number"
+Math PI documentation println
+
+Fancy Documentation documentation println
+
+Fancy Documentation for: Foo append: "Re-Openning Foo class to add more docs."
+
+class Foo {
+  """
+     Fancy provides an incremental documentation feature.
+  """
+  self documentation println
+}
+
+

data/examples/documentation_formatters.fy

@@ -0,0 +1,25 @@
+# documentation_formatters.fy
+# Example of fancy's documentation formatters
+
+foo = Object new
+
+Fancy Documentation for: foo is: """
+## Fancy documentation.
+
+ It should be possible to set documentation for any _arbitray object_.
+ Doing so will expose it on the API documents.
+ This can be useful for constants, or singleton objects.
+
+## Fancy Documentation formatters
+
+ Fancy you to create custom documentation formatters,
+ thus, allowing you to display an object document in a well
+ formatted way for different environments, eg. when using the
+ interactive REPL you may want *ANSI* _colored_ output, or maybe
+ we create a tool to generate MAN(1) pages, and fdoc tool
+ to generate HTML API docs.
+
+"""
+
+Fancy Documentation for: foo . format: 'markdown . println
+

data/examples/echo.fy

@@ -0,0 +1,16 @@
+# echo.fy
+# Outputs contents of files
+
+ARGV[1] if_do: |filename| {
+ try {
+    File open: filename modes: ['read] with: |f| {
+      until: { f eof? } do: {
+        f readln println
+      }
+    }
+  } catch IOError => e {
+    "[ERROR] " ++ (e message) println
+  }
+} else: {
+  "Usage: fancy echo.fy [filename]" println
+}

data/examples/empty_catch.fy

@@ -0,0 +1,4 @@
+try {
+  "Empty catch" println
+} catch StdError => e {
+}

data/examples/exception.fy

@@ -0,0 +1,9 @@
+try {
+  "Hola" println
+  StdError new: "Hello" . raise!
+  "Hi" println
+} catch StdError => e {
+  e println
+} finally {
+  "Adios" println
+}

data/examples/factorial.fy

@@ -0,0 +1,12 @@
+# factorial.fy
+# Example of factorial
+
+class Fixnum {
+  def factorial {
+    1 upto: self . product
+  }
+}
+
+1 upto: 10 do_each: |i| {
+  i to_s ++ "! = " ++ (i factorial) println
+}

data/examples/fibonacci.fy

@@ -0,0 +1,16 @@
+# fibonacci.fy
+# Example of fibonacci numbers
+
+class Fixnum {
+  def fib {
+    match self -> {
+      case 0 -> 0
+      case 1 -> 1
+      case _ -> self - 1 fib + (self - 2 fib)
+    }
+  }
+}
+
+15 times: |x| {
+  x fib println
+}