Functional Programming

Hi /prog/, I needs help.

Could people give me some code in a functional language, specifically, I'd like some Haskell and OCaml. Lisp is also welcome. Other functional languages are also welcome (and appreciated), though I'm most interested in the mentioned ones.

The code snippet I'm looking for is to convert a string to uppercase, but I want the code to do this manually (so no calling some magical toupper function or whatever).
That means, this Haskell code is not valid, since it uses toUpper (though, if you define toUpper, I suppose I'll count it as valid).

import Data.Char
s = "alphaBETA"
upper = map toUpper s
Preferably I'd like code which does not use map or other such constructs (though if thats too dificult, then ignore this requirement). Also, if possible, I'd like code that converts the string both in place and by constructing a new string.


Basically, I want to see different approaches to doing this in different languages. All serious replies are appreciated. Trolls appreciated only if they make me laugh.

fib = 1 : 1 : zipWith (+) fib (tail fib)

>>2
Is that Haskell?

Other functional languages are also welcome (and appreciated), though I'm most interested in the mentioned ones.

There are no other functional languages besides Lisp, Haskell and OCaml.

>>4
Java has functions, I would call it functional.


#include <stdio.h>
#include <stdlib.h>

char to_upper( char foo )
{
    return foo >= 'a' && foo <= 'z' ? foo + ('A' - 'a') : foo;
}

char to_lower( char foo )
{
    return foo >= 'A' && foo <= 'Z' ? foo + ('a' - 'A') : foo;
}

void map_str( char * str, char (func)(char) )
{
    if ( !*str )
    {
        return;
    }

    *str = func(*str);
    map_str( ++str, func );
}


void map_str_to( const char * str, char * dst, char (func)(char) )
{
    if ( !*str )
    {
        return;
    }

    *dst = func(*str);
    map_str_to( ++str, ++dst, func );
}


int main( int argc, char ** argv )
{
    char convert[] = "ZERO 1 infinity";
    char *converted = malloc(sizeof(convert)+1);
    map_str( convert, to_upper );
    puts( convert );
    map_str_to( convert, converted, to_lower );
    puts( converted );
    return 0;
}

>>5
Java also functions. So it must be functional.

int *compose(int(*f)(int),int(*g)(int))(int){
 int ret(int n){
  return f(g(n));
 }
 return ret;
}

>>6
Doesn't work for Unicode, bitch.

>>9

    .　　　　／／　　　　　 　 　 　 ＿／_,∠＿＿　　　　　
    　　　 /.:/　　　　　'" ￣￣ ヘ　　　　　＿＿　¨.二ﾆ=-
    　　　 {::{　　／: : : : : : : : : : : : :＼: : : : : : : : : :｀丶、
    　　 　 ヾ　/.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:ヽ.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:ヽ　
    　　　　　>′.::.::.::.::.::.::.::.::.ヽ.::.::.::.::.::. ＼-.::.::.::.::.:＼_.::.::.＼
    .　　 　 /.::.::.::／ :.::.::.::.::.::.:: |.::.::.::.::.::.::.|::＼.::.＼.::.::.:＼｀＼
    　　　　|.::.:: /.::.::.::.::.::／|⌒:j.::.::.:.:::.::.:: |.::| _＼.::.ヽ.::.::. ヽ　
    　　　　|.::.:/.::.:: /.::.::.::.: | .:/ ＼.::.::.::.::.:ﾚﾁ斤| ﾄ.::.',.::.::.::.:l
    　　　　|.:/.:,'.::.::|.::.::.::.::/|:/__　　ヽ.::.::.::|ち:::|　{.::?＼.::.j　
    　　 　 Y.:/! .:: l.::.::.: / ｨチ行 　　ヽ.::.| Vﾋｉ　',::.l 　　　　　So what, you weeaboo.
    　　　　 ﾚ.::|.::.::.|.::.::.ﾊfﾍﾉ:::::ハ　　　∨　 　 ・}.::.ｌ　　　　
    　　　　 lrｰゝ､∧.::.ｌ∧　V;少''　　 　 _'　 　 ｲ.::.:|.　
    　　　　 j ＼　＼∨.::. ヽ, -、　 　 こ.ノ　∠l | ::.:
    .　　 　 ,'.::.::.（￣｀ヾｰ､_/　/、 ＿＿　／//}│ .:l　
    . 　 　 /.::.::.: (￣ ヽﾉ　 　 {＼　　　ハ　/V/│.::.!
    　　　/.::.::.::.:r'¨`ｰt'　　　ﾉ.::. ＼ｰ‐'´|　川{　∨ﾘ　　
    .　　/ :.::.::.::. `ﾄ ー′　 ｲ ＼.::ヽ＼　| // ﾉ　
    　／.::.::.::.::.::.:人ゝ､_　　 lﾉ　ﾊ.:.:}∨ヽ!シｲ　
    /.::/.:::.:::.::.::〃　＼ ＼／　/） V二ﾆ¨´¨`ヽ
    ::/|.::/.:::.::.::{{　　　＼三／人　　　 /　　}　 ＼　
    /　V.:::.:::.:::.:::ヾ　　　　　 ｲ　 ｀　　（　　 {｀ヽ､_ ＞

>>10
Moonspeak is not the only language that uses Unicode. Plenty of other equally worthless languages use it too. Personally, I fully support intentionally breaking applications and websites for non-English speakers. It gives them more motivation to learn English.

>>11
Enjoy your λack of proper symbols in programming λanguages.

It doesn't matter because women prefer cunnilingus anyway you dumb stupidhead

>>13
brilliant troll

thanks. it was so organic. the urge to paste it in just came through me like a spirit guide

>>1
By disallowing map you're basically disallowing functional style, and by disallowing the built-in upper-case function you're just asking for incomplete upcase implementations that don't handle Unicode characters or show off the language in question (unless you're just wondering how to add 32 to a number in various languages). I'm not sure what you hope to learn from asking such a stupid question.

But here's Lisp anyway. This is the usual style.

(defun my-string-upcase (string)
  (let ((a ""))
    (tagbody
     capo
       (let ((c (elt string 0)))
     (setf string (subseq string 1))
     (if (and (char< c #\A) (alpha-char-p c))
         (setf a (concatenate 'string
              a (string (code-char (+ (char-code c) 32)))))
         (setf a (concatenate 'string a (string c)))))
       (unless (= (length string) 0) (go capo)))
    a))
And Lisp isn't a functional language. It's the multi-paradigm language.

>>16
Dang. Tab issues.

What does tagbody and capo mean

>>16
Wait... that's not right.

>>16
CL-USER> (my-string-upcase "test")
"test"

I lol'd heartily.

>>16
Here's an optimized version of your code:

(defun my-string-upcase (string)
    string)

>>1
converts the string in place destructively in lisp

(map-into s #'to-upper s)

in python I guess you could write something simpler like

def mapInto(c, f):
    for i in xrange(c.length):
         c[i] = f(c[i])

now you can write something like

mapInto("alphaBETA", upper)

>>22
You didn't read >>1, did you?

Preferably I'd like code which does not use map or other such constructs (though if thats too dificult, then ignore this requirement).
besides, I just wanted to post something in the code in place. I just didn't define the upper functions.

(defun my-string-upcase (string)
  (let ((a "")
    (c))
    (tagbody
     capo
       (setf c (elt string 0))
       (setf string (subseq string 1))
       (if (and (char> c #\Z) (alpha-char-p c))
       (setf a (concatenate 'string
                a (string (code-char (- (char-code c) 32)))))
       (setf a (concatenate 'string a (string c))))
       (unless (zerop (length string)) (go capo)))
  a))
fix'd

>>25
Is there a reason you use tagbody?

>>26
For proper GOTO style.

>>25
[code]    upper(string)[/code[
fix'd

Fuck proper GOTO style, I want GTFO style!

YEAH!!!

((x>='a')&&(x<='z'))?x&223:x

>>28
Way to not follow the instructions. That would be (string-upcase string), in any event.

And so life imitates art.

>>31
Enjoy your lisp.

>>33
(thank you)

>>33
(domo 'arigato)

var s = 'alphaBETA';
s = ''['toUpperCase']['apply'](s);

>>36
you could just do
s=s.toUpperCase();
but that's boring.

>>16, OP here.
Well, using map is fine, but I wanted to see alternatives (different ways to loop through each character in a string, check is it lowercase and if yes, add 32 to that character, then finally returning the new string).
As for why, I just used it as a random piece of sample code, anything that contained some sort of loop, some sort of codnition and some sort of modification or construction of data would be fine. What I am trying to do is figure out what fundamental constructs can be used to do most kinds of operations, things like map, fold, filter and so on.

>>38
Uh, ``fundamental constructs'' are relative to the language. You really shouldn't be using loops in functional languages, unless you have to.

>>4
A couple more functional languages http://en.wikipedia.org/wiki/Category:Functional_logic_programming_languages