-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
solved my last problem, and now i'm stucker than before:
(def open 0)
(def p1 1)
(def p2 2)
(def emptyfield [open open open open open open open open open])
(defn updated [seq index replacement]
(concat
(take index seq)
[replacement]
(drop (inc index) seq)))
(defn indexOf [x y] (+ x (* y 3)))
(defn withmove [x,y,player,field]
(updated field (indexOf x y) player))
(defn winner [field]
(defn winPred [player]
(defn rowwin [row]
(let [beginIndex (indexOf 0 row)
currow (subvec (force field) beginIndex (+ 3 beginIndex))]
(defn ownedByPlayer [value])
every? ownedByPlayer currow))
(defn colwin [col]
(let [beginIndex (indexOf col 0)
curcol (take-nth 3 (drop beginIndex field))]
(defn ownedByPlayer [value])
every? ownedByPlayer curcol))
(loop [cnt 0]
(if (= cnt 3) false (or (rowwin cnt) (colwin cnt) (recur (inc
cnt))))))
(let [winnerIfExists (filter winPred [p1 p2])]
(if (empty? winnerIfExists) open (first winnerIfExists))))
(let [moves [[0 0 p1] [1 0 p1] [2 0 p1]]]
(defn fold [field nextmove]
(withmove (nth nextmove 0) (nth nextmove 1) (nth nextmove 2) field))
(let [endstate (reduce fold emptyfield moves)]
(println endstate)
(println (winner endstate)))
)
how to convert a lazy seq into a persistent vector?
Am 03.09.2011 23:38, schrieb Luc Prefontaine:
> On Sat, 3 Sep 2011 13:43:42 -0700 (PDT) HamsterofDeath
> <d.haup...@googlemail.com> wrote:
>
>> this might seem like a stupid question, but for me, not knowing
>> the type of something is like being stuck in a dead end for
>> anything non trivial.
>
> It's not stupid, it's normal :)
>
> In functional programming, most of the time you would like to write
> functions that do not need to know their arguments too intimately.
> You would like to work on collections, maps, ...
>
> Of course at some point you will need to write functions that will
> look closer to their arguments.
>
> You can pass functions to generic ones and isolate that type
> knowledge within them. No need to spread this everywhere.
>
>> i've made a few little experiments with clojure (not much, just
>> testing some features) and i see how powerful clojure can be -
>> for small to medium sized problems with simple input and output -
>> a*- pathfinding, for example.
>>
>> but how would i port a complex object graph (let's say 15
>> different classes with 3-7 fields each - person, contacts,
>> orders, shipping details) to clojure? how would i handle it?
>
> defrecord might help you a bit here. It may feel a bit "like
> home". defrecord fields can be referenced as map entries
> (:field-name ...).
>
> You can also define protocols that associated with defrecord and
> may ease your pain by implementing familiar functions to navigate
> in the hierarchy.
>
> Not sure if using a library written by someone else to handle these
> things is the proper thing to do right now. I feel you need to
> break your teeth a bit :) (It took me three months to get used to
> immutability :))
>
>> the main problems i see are: * do i have to actually remember the
>> complete structure and field names and the exact spelling? using
>> statically types languages like java or scala, the ide
>> autocomplete features really help here.
>
> If you use obvious names that match the problem domain this should
> be easy to overcome. Protocols could help you here by hiding some
> complex navigation but please refrain implementing "getters" for
> all individual fields :))
>
>> * what about renaming a field or method?
>
> Yep of course you will not have this nice refactoring feature where
> you type in place the new name and get the IDE to fix this
> everywhere for you. But on the other hand you should have at least
> 10 times less code compared to java and less side effects to
> debug. It should not be too hard to do this using a standard text
> search. I use Eclipse and the straight "file" search. I would never
> exchange Clojure for Java and the automated "Refactoring"
> commands.
>
> If you encapsulate frequently exposed fields in functions you
> should be able to reduce the footprint of the code where these
> things are exposed. Hence the name changes would be easy to
> implement. You would confine these functions in a specific name
> space which decrease the like hood of missing a change.
>
>> * if a function needs an instance of the root class of the
>> complex graph above as a parameter - how do i know this at all?
>> am i lost without good documentation of this function? in java, i
>> just know what a method needs because it has a signature.
>>
> Use the doc string when defining a fn:
>
> (defn blbl "Returns the meaningful "blblblbl..." string. It expects
> a single parameter, the length of the returned string" [length]
> ...)
>
> You can describe the expected inputs and the result, ... Do the
> same thing with your name space definitions, protocols. ...
>
> It's easy, fits with your programming flow and is non-obtrusive.
>
>
- --
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.14 (MingW32)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/
iQIcBAEBAgAGBQJOY61vAAoJENRtux+h35aG3ToQALfT3XdikxD5OrzaTwXC5Hbo
e1oymb0MZoKpHjStrjpHPgvhEB5jt04TTIcGoPfyZoOhT56PrZLMtjD5ItZFVJvi
41JvhrMb1DMs+4jwOwkCvjlmB7ZhZEeQE7T1nWIoJYDNm1NTNZCYoCiIs9VISt+9
7vNCXg10sbWV8plIJNqLtdWRxNzY7B0wP77G7h3+2H91V/sYqLBjfrVkSOL0zoYo
QUIAWDWihUWk0cvVRBPe5dKd8Hu1z74frhAm6TsGnfXMXEFhXpQ9WoUkwhYgz9Ap
ZJFxsRgEQtX+gkD/fku3hMGIjR6zvLuHbbrx1kBVxfeHWgOFc5htEq1kIy+vUOVZ
5xuBEMSukMIvYM4O9Kschv2joUuy8bcXVhuVlSMJRk0jhiwggxNIcx2kE0ug47Dh
iGaOEYoezkXXwuEsQ568P4Gfd309TujKrvC1YHSNBf1QiayXkZ54uoCwBqBrZ8FJ
dea/vJdaFpyrkuhABBD7XqwTzoGwT6JTmD+csRwIRXAKCbXq1ZopzKzuAMyCOs8A
o8fPa0A4vJxjLj5Bh1WKzB3nIfIjagT3SGMiMDweMW+ydGPMDc8xCJz5+W/nC1pU
oQfYJYl5VNWadsQyHRylQhCoKvgrcijy23EnrYdf9sSKM53+Nig5Iff0UOz0YCoL
v1iG1P5NqhUVNXgnDT65
=X2Q3
-----END PGP SIGNATURE-----
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
