The connection between the language in which we think/program and the problems and solutions we can imagine is very close. For this reason restricting language features with the intent of eliminating programmer errors is at best dangerous.
-- Bjarne Stroustrup
Mr. Stroustrup is the inventor of the C++ programming language, but quite an insightful person nevertheless.
Also, here is a picture of an ostrich:
\"."
badWords = ['ape', 'monkey', 'simian', 'gorilla', 'evolution']
pattern = new RegExp badWords.join('|'), 'i'
isAcceptable = (text) ->
!pattern.test text
show isAcceptable 'Mmmm, grapes.'
show isAcceptable 'No more of that monkeybusiness, now.'
digits = new RegExp '\\d+'
show digits.test '101'
HTML =
tag: (name, content, properties) ->
name: name
properties: properties
content: content
link: (target, text) ->
HTML.tag 'a', [text], {href: target}
# ... many more HTML-producing functions ...
# As defined in the prelude
globalize = (ns, target = global) ->
target[name] = ns[name] for name of ns
globalize HTML, window?
show link 'http://citeseerx.ist.psu.edu/viewdoc/' +
'download?doi=10.1.1.102.244&rep=rep1&type=pdf',
'What Every Computer Scientist Should Know ' +
'About Floating-Point Arithmetic'
range = (start, end, stepSize, length) ->
if stepSize is undefined
stepSize = 1
if end is undefined
end = start + stepSize * (length - 1)
result = []
while start <= end
result.push start
start += stepSize
result
show range 0, undefined, 4, 5
defaultTo = (object, values) ->
for name, value of values
if not object.hasOwnProperty name
object[name] = value
range = (args) ->
defaultTo args, {start: 0, stepSize: 1}
if args.end is undefined
args.end = args.start +
args.stepSize * (args.length - 1)
result = [];
while args.start <= args.end
result.push args.start
args.start += args.stepSize
result
show range {stepSize: 4, length: 5}
runOnDemand ->
eval 'function IamJavaScript() {' +
' alert(\"Repeat after me:' +
' Give me more {();};.\");};' +
' IamJavaScript();'
runOnDemand ->
CoffeeScript.eval 'alert ((a, b) -> a + b) 3, 4'
weatherAdvice = (weather) ->
show 'When it is ' + weather
switch weather
when 'sunny'
show 'Dress lightly.'
show 'Go outside.'
when 'cloudy'
show 'Go outside.'
when 'tornado', 'hurricane'
show 'Seek shelter'
else
show 'Unknown weather type: ' + weather
weatherAdvice 'sunny'
weatherAdvice 'cloudy'
weatherAdvice 'tornado'
weatherAdvice 'hailstorm'
for i in [20...30]
if i % 3 isnt 0
continue
show i + ' is divisible by three.'
class Point
constructor: (@x, @y) ->
pt = new Point 3, 4
{x, y} = pt
show "x is #{x} and y is #{y}"
firstName = "Alan"
lastName = "Turing"
name = {firstName, lastName}
show name
decorate = ({firstName, lastName}) ->
show "Distinguished #{firstName} " +
"of the #{lastName} family."
decorate name
pi = π = Math.PI
sphereSurfaceArea = (r) -> 4 * π * r * r
radius = 1
show '4 * π * r * r when r = ' + radius
show sphereSurfaceArea radius
evens = (n) -> i for i in [0..n] when i % 2 is 0
show evens 6
steppenwolf =
title: 'Tonight at the Magic Theater'
warning: 'For Madmen only'
caveat: 'Price of Admittance: Your Mind.'
caution: 'Not for Everybody.'
stipulations = (text for key, text of steppenwolf \
when key in ['warning', 'caveat'])
show stipulations
show ultimatum for ultimatum in stipulations \
when ultimatum.match /Price/
tautounlogical = "the reason is because I say so"
splitStringAt = (str, n) ->
[str.substring(0,n), str.substring(n)]
[pre, post] = splitStringAt tautounlogical, 14
[pre, post] = [post, pre] # swap
show "#{pre} #{post}"
[re,mi,fa,sol,la,ti] = [1..6]
[dal,ra...,mim] = [ti,re,fa,sol,la,mi]
show "#{dal}, #{ra} and #{mim}"
[key, word] = if re > ti then [mi, fa] else [fa, mi]
show "#{key} and #{word}"
class Widget
id: 'I am a widget'
display: => show @id
class Container
id: 'I am a container'
callback: (f) ->
show @id
f()
a = new Widget
a.display()
b = new Container
b.callback a.display
n = 3
f = -> show "Say: 'Yes!'"
do f
(do -> show "Yes!") while n-- > 0
echoEchoEcho = (msg) -> msg() + msg() + msg()
show echoEchoEcho -> "No"
runOnDemand ->
for i in [1..3]
do (i) ->
setTimeout (-> show 'With do: ' + i), 0
for i in [1..3]
setTimeout (-> show 'Without: ' + i), 0
class BinaryHeap
# Public
#--------
constructor: (@scoreFunction = (x) -> x) ->
@content = []
push: (element) ->
# Add the new element to the end of the array.
@content.push element
# Allow it to bubble up.
@_bubbleUp @content.length - 1
pop: ->
# Store the first element so we can return it later.
result = @content[0]
# Get the element at the end of the array.
end = @content.pop()
# If there are any elements left, put the end
# element at the start, and let it sink down.
if @content.length > 0
@content[0] = end
@_sinkDown 0
result
size: -> @content.length
remove: (node) ->
len = @content.length
# To remove a value, we must search through the
# array to find it.
for i in [0...len]
if @content[i] is node
# When it is found, the process seen in 'pop'
# is repeated to fill up the hole.
end = @content.pop()
if i isnt len - 1
@content[i] = end
if @scoreFunction(end) < @scoreFunction(node)
@_bubbleUp i
else
@_sinkDown i
return
throw new Error 'Node not found.'
# Private
#---------
_bubbleUp: (n) ->
# Fetch the element that has to be moved.
element = @content[n]
# When at 0, an element can not go up any further.
while n > 0
# Compute the parent element index, and fetch it.
parentN = Math.floor((n + 1) / 2) - 1
parent = @content[parentN]
# Swap the elements if the parent is greater.
if @scoreFunction(element) < @scoreFunction(parent)
@content[parentN] = element
@content[n] = parent
# Update 'n' to continue at the new position.
n = parentN
# Found a parent that is less,
# no need to move it further.
else
break
return
_sinkDown: (n) ->
# Look up the target element and its score.
length = @content.length
element = @content[n]
elemScore = @scoreFunction element
loop
# Compute the indices of the child elements.
child2N = (n + 1) * 2
child1N = child2N - 1
# This is used to store the new position of
# the element, if any.
swap = null
# If the first child exists (is inside the array)...
if child1N < length
# Look it up and compute its score.
child1 = @content[child1N]
child1Score = this.scoreFunction child1
# If the score is less than our elements,
# we need to swap.
if child1Score < elemScore
swap = child1N
# Do the same checks for the other child.
if child2N < length
child2 = @content[child2N]
child2Score = @scoreFunction child2
compScore = if swap is null
elemScore
else
child1Score
if child2Score < compScore
swap = child2N
# If the element needs to be moved,
# swap it, and continue.
if swap isnt null
@content[n] = @content[swap]
@content[swap] = element
n = swap
# Otherwise, we are done.
else
break
return
(exports ? this).BinaryHeap = BinaryHeap
runOnDemand ->
sortByValue = (obj) -> _.sortBy obj, (n) -> n
buildHeap = (c, a) ->
heap = new BinaryHeap
heap.push number for number in a
c.note heap
declare 'heap is created empty', [],
(c) -> c.assert (new BinaryHeap).size() is 0
declare 'heap pop is undefined when empty', [],
(c) -> c.assert _.isUndefined (new BinaryHeap).pop()
declare 'heap contains number of inserted elements',
[arbArray(arbInt)], (c, a) ->
c.assert buildHeap(c, a).size() is a.length
declare 'heap contains inserted elements',
[arbArray(arbInt)], (c, a) ->
heap = buildHeap c, a
c.assert _.isEqual sortByValue(a), \
sortByValue(heap.content)
declare 'heap pops elements in sorted order',
[arbArray(arbInt)], (c, a) ->
heap = buildHeap c, a
for n in sortByValue a then c.assert n is heap.pop()
c.assert heap.size() is 0
declare 'heap does not remove non-existent elements',
[arbArray(arbInt), arbInt],
expectException (c, a, b) ->
if b in a then c.guard false
heap = buildHeap c, a
heap.remove b
declare 'heap removes existing elements',
[arbArray(arbInt), arbInt], (c, a, b) ->
if not (b in a) then c.guard false
aSort = sortByValue _.without a, b
count = a.length - aSort.length
heap = buildHeap c, a
heap.remove b for i in [0...count]
for n in aSort then c.assert n is heap.pop()
c.assert heap.size() is 0
test()
# CoffeeScript
runOnDemand ->
start = new Date()
N = 1000000
a = Array(N)
for i in [0...N]
a[i] = Math.random()
s = 0
for v in a
s += v
t = 0
for v in a
t += v*v
t = Math.sqrt t
duration = new Date() - start
show "N: #{N} in #{duration*0.001} s"
show "Result: #{s} and #{t}"
# CoffeeScript encoding: utf-8
# Create variations to try
permute = (L) ->
n = L.length
return ([elem] for elem in L) if n is 1
[a, L] = [ [L[0]], L.slice 1 ]
result = []
for p in permute L
for i in [0...n]
result.push p[...i].concat a, p[i...]
result
# Check a variation
test = (p, n) ->
for i in [0...n - 1]
for j in [i + 1...n]
d = p[i] - p[j]
return true if j - i is d or i - j is d
false
# N queens solver
nQueen = (n) ->
result = []
for p in permute [0...n]
result.push p unless test p, n
result
# Repeat a string a number of times
rep = (s, n) -> (s for [0...n]).join ''
# Display a board with a solution
printBoard = (solution) ->
board = "\n"
end = solution.length
for pos, row in solution
board += "#{end - row} #{rep ' ☐ ', pos} " +
"♕ #{rep ' ☐ ', end - pos - 1}\n"
# Using radix 18 hack!
board += ' ' + (n.toString 18 \
for n in [10...18]).join(' ').toUpperCase()
board + "\n"
# Find all solutions
solve = (n) ->
for solution, count in nQueen n
show "Solution #{count+1}:"
show printBoard solution
count
runOnDemand ->
start = new Date()
solve 8 # Normal chessboard size
show "Timing: #{(new Date() - start)*0.001}s"