dtchepak

I've been having a look around at various definitions of OO. Here's some of the ideas google turned up:

• http://c2.com/cgi/wiki?DefinitionsForOo
• http://c2.com/cgi/wiki?ObjectOrientedForDummies
• http://c2.com/cgi/wiki?NobodyAgreesOnWhatOoIs
• http://c2.com/cgi/wiki?NygaardClassification -- Classifications of procedural, functional, constraint, OO programming
• http://c2.com/cgi/wiki?NygaardClassificationContested -- Contests to the aforementioned classifications
• http://www.tonymarston.net/php-mysql/what-is-oop.html -- Interesting section on "What OOP is not"
• http://apocalisp.wordpress.com/2008/12/04/no-such-thing/ -- No such thing as OO
• http://www.paulgraham.com/reesoo.html

dtchepak

using System;
using System.Collections.Generic;
using System.Linq;

namespace MarkupParser
{
    public abstract class Node
    {
        public static Parser<String> TextParser()
        {

dtchepak

-- Want :: [a -> a] -> a -> a
-- Emulates: an . … . a3 . a2 . a1

Prelude> let a = [reverse, (++ " world"), (++ "!")]

-- Given "olleh", it should:
--   * reverse it:      "hello"
--   * append " world": "hello world"
--   * append "!":      "hello world!"

dtchepak

"I say “surprising” because anything with as exotic a name as “monad” — derived from category theory, one of the most abstract branches of mathematics — is unlikely to be very useful to red-blooded programmers. But one of the joys of functional programming is the way in which apparently exotic theory can have a direct and practical application, and the monadic story is a good example."

Simon PEYTON JONES, Tackling the Awkward Squad

dtchepak

instance Functor ((->) t) where
    --fmap :: (a -> b) -> (t -> a) -> (t -> b)
    fmap = (.)

instance Monad ((->) t) where
    return = const
    --(>>=) :: (t -> a) -> (a -> t -> b) -> t -> b
    f >>= g = \t -> let a = f t
                    in g a t

dtchepak

        public class Lens<T, TValue>
        {
            public Func<T, TValue> Get { get; private set; }
            public Func<TValue, T, T> Set { get; private set; }

            public Lens(Func<T, TValue> get, Func<TValue, T, T> set)
            {
                Get = get;
                Set = set;
            }

dtchepak

        // SAMPLE ONLY -- DON'T USE FOR REAL STUFF UNLESS YOU'VE REVIEWED AND TESTED :)
        // Needs work to make robust: check property type's class has default ctor and so on.
        // Can also filter out interfaces as these will be auto-subbed.
        public static T SubFor<T>() where T : class
        {
            var gettableVirtualProps = typeof(T).GetProperties()
                .Where(x => x.CanRead && x.GetGetMethod().IsVirtual)
                .Select(x => x);

            var sub = Substitute.For<T>();

dtchepak

import Control.Monad
import Data.List
import Data.Maybe

factorBy :: Int -> Int -> Maybe (Int, Int)
factorBy n factor = if snd result == 0 then Just (fst result, factor)
                    else Nothing
    where result = n `divMod` factor

firstFactor :: Int -> Maybe (Int, Int)

dtchepak

module HaskellKoans.AboutAsserts where

import HaskellKoans.KoanBase

aboutAsserts = 
    Koans "HaskellKoans.AboutAsserts"
        [ koanAboutQuestion
        , koanAboutBool
        , koanAboutEquality
        ]

dtchepak

randomChar :: (RandomGen g) => State g Char
randomChar = state $ randomR ('a','z')

randomStringWithLength :: (RandomGen g) => Int -> State g String
randomStringWithLength i = replicateM i randomChar

randomString :: (RandomGen g) => State g String
randomString = state $ \g ->
    let (charsToGen, g') = randomR (1,10) g
    in  runState (randomStringWithLength charsToGen) g'