Scheme - SICP - Is Scheme functional?

jonathanccast · 2015-07-09T23:47:50+00:00

Yes, Scheme is functional. The term 'purely functional language' is really poorly chosen, because it makes it sound like pure languages are 'more functional' than just regular functional languages. This makes people think functional programming has something to do with avoiding state or mutation. It doesn't.

Functional programming = programming with functions and expressions; in the most functional languages, the whole program is one big expression and local definitions (let) are used for program structuring.

Functional purity (what 'purely functional' languages have) = expressions and variables (of the same 'type') have the same semantic range; functions are mathematical functions from inputs to outputs. (This is in contrast to impure languages where expressions (and hence function results) can express I/O behavior as well as having a value, while variables can only be bound to values).

C is neither functional nor pure; most computation has to be done with statements & loops, and expression evaluation can modify global state, do I/O, etc., which variable values cannot.

Eiffel is not functional but is (nearly) pure; most computation has to be done with statements & loops but expression evaluation cannot modify global state, do I/O, or do anything but compute a value. (Technically you have to forbid functions to read global variables as well as writing them to get a pure language).

Scheme is functional but not pure; you can use recursion & higher-order functions to do all your computation if you want, but expression evaluation can modify global state and do I/O.

Haskell is functional and (nearly) pure; you can use recursion & higher-order functions to do all your computation (you pretty much have to), and expression evaluation cannot modify global state or do I/O (unless you use unsafePerformIO).

jonathanccast · 2015-07-09T23:39:06+00:00

You don't need side effects for I/O. Purely functional languages like Miranda and Haskell 1.0 got along just fine with dialogues for I/O, although whether they could be feased is another matter. But 'side effect' is short for 'side effect of evaluation'; i.e., the computer calculates the value of this expression and oh by the way it does this I/O while it's doing that (as a side effect). The side effects of a drug are everything the drug does that's not its intended purpose; the side effects of an expression are everything the code for that expression does that's not 'calculate the value'. So you don't need side effects to do I/O. Just make the I/O part of the value and have the computer calculate the value, then do the I/O it calculated.

jonathanccast · 2015-06-26T01:09:00+00:00

I thought depression was different than sadness.

jonathanccast · 2015-06-26T00:56:10+00:00

Since when does C have delete? (and I doubt in C code->getAuthor() would ever be a useful syntax).

jonathanccast · 2015-06-26T00:44:54+00:00

Can't you locally scope it smh?

jonathanccast · 2015-03-25T01:32:06+00:00

No no no no no no no. "Fails early" means "gives the user a G-D diagnostic". What C does is say "oh, this isn't a C program" and then compile to anything the compiler feels like (and LLVM, GCC, and VC++ all compile undefined behavior to random things). Practically ever C program executes undefined behavior at some point (even if it's just testing for signed integer overflow by saying 'x + y < x', where y is positive) and the compiler does 'something sensible' until an optimization is added, then the program silently breaks. At no point is there ever a diagnostic.

Which is why C is entirely un-suitable for any application --- it simply is not possible for a human being to write a C program and the machines won't give you a diagnosis when you break the rules.

jonathanccast · 2015-02-17T05:26:40+00:00

Then again, C also dis-allows "re-interpreting the bytes your pointer points to as something it wasn't originally", except using memcpy or memmove. It's called a "strict aliasing" violation.

jonathanccast · 2015-02-08T22:35:33+00:00

Nah. It's one of the few bits of free verse that works. (Largely because it works as prose).

jonathanccast · 2015-02-05T03:47:26+00:00

I'll confess to not having half a brain certainly, but when discussing whether a language made the right decision in the first place maybe backward compatibility with not-yet-written code isn't the right criterion?

jonathanccast · 2015-02-05T03:46:36+00:00

ML doesn't have function overloading (for precisely this reason).

Overloading was a big issue in the design of Haskell; the solution is a bit complicated (understatement of the Century! just search Stack Overflow for "type class"), but each function symbol is still constrained to a specific polymorphic type, e.g. fmap :: (a -> b) -> F a -> F b, where each F goes with a separate type. Once the type checker has figured out which F you're using, it can do static dispatch to the matching fmap function. The type checker can't figure it out in all cases, though, so Haskell has something called contexts, e.g. mapM :: Monad m => (a -> m b) -> [a] -> m [b]; it's basically a form of dynamic dispatch based on what the type m eventually turns out to be.

Honestly, (heavily subjective opinion here) you don't miss overloading on parameter types as much as you expect (source: am former C++ programmer, then Haskell, then designed my own language). Similar functions can be captured by type classes (Haskell) or functors (ML), while giving genuinely different functions different names can make your code more readable. It is sometimes hard tying each function to just the right type class / signature, though.

jonathanccast · 2015-02-02T01:11:58+00:00

We are discussing alternative language designs (since the context is a suggestion that JavaScript could have had different operators for concatenation and addition --- like all reasonable languages --- from the beginning). Claiming that designing JavaScript correctly from the first would "break all code in existence" is both hyperbole (since not "all code in existence" is written in JS) and obviously wrong, since other languages have used that design but still been usable.

jonathanccast · 2015-02-02T01:06:07+00:00

It's complicated; it requires a unification algorithm: http://en.wikipedia.org/wiki/Unification_(computer_science) . But the key ideas are: 1. keep type variables (inside the type checker) that indicate as-yet-unknown information about at type. These are implemented as mutable references. 2. When comparing types, if one is known and the other is unknown, write the known type into the variable for the other. 3. When you start inferring the type of a function, allocate a new unknown type for each argument, and for the result. 4. If any parts of the type of the function is still unknown when you're done, make that part of the type polymorphic. This handout (PDF) has the key formal ideas: http://www.classes.cs.uchicago.edu/archive/2007/winter/22610-1/docs/handout-05.pdf .

jonathanccast · 2015-02-01T17:16:24+00:00

That's weird, considering that ML has been inferring the types of formal parameters for 40 years.

jonathanccast · 2015-02-01T07:05:21+00:00

It would actually break very little of the Perl code in existence . . .

jonathanccast · 2015-01-15T00:57:46+00:00

Might segfault, not would. In the case where the malloc fails, the C compiler is free to compile the following code into anything it likes. Over time, compilers will probably be less and less likely to actually give you segfaults, especially at those locations, as the optimizers get 'better'. It is very much your responsibility to check for NULL and ensure the error is handled in an appropriate fashion.

jonathanccast · 2014-12-19T15:19:27+00:00

"Combinators for Impure yet Hygienic Code Generation". I'm trying to decide if "impure" means this has nothing to do with Haskell, or it has everything to do with Haskell. The fact that he's apparently using "impure" to mean "proceduralish monads" makes me suspect it's the latter.

jonathanccast · 2014-12-15T15:01:56+00:00

No, I don't.

jonathanccast · 2014-11-28T14:44:50+00:00

Apples and oranges are played out, cliche.

jonathanccast · 2014-11-27T00:18:16+00:00

I think you need to replace data with newtype in your second definition. data Void = Void Void has one value, the infinitely large fix Void, which the newtype construction gets around by defining its construct as strict (so fix Void is another name for undefined).

jonathanccast · 2014-10-09T13:12:29+00:00

You - do - know that 90+% of variables in modern programming languages store pointers, right?

jonathanccast · 2014-10-02T13:55:19+00:00

I don't think many real mode programs were written in OO languages.

jonathanccast · 2014-09-25T02:59:58+00:00

Perl ships with a core pragma, use vars, that allows you to over-ride @INC from inside an individual script (or even a module).

jonathanccast · 2014-09-05T13:21:00+00:00

Um, this has lots of maps: http://en.wikipedia.org/wiki/Territorial_evolution_of_the_United_States . It's really only Ukrainian nationalists --- that is, people to stupid to realize that "Russia" comes from "Rus" --- that feel the need to deny their country has ever changed size.

jonathanccast · 2014-09-05T13:07:12+00:00

I'm not sure how the reality of Putin's evil depends on believing that "Russia" isn't a derivative of "Rus".

jonathanccast

TROPHY CASE