haskell中的函数单独声明

Question

Is there a way (maybe some pragma or extension (I'm using GHC )) that allow to declare different patterns of function separately?

For example, I can do that:

fun1 1 = "1"
fun1 2 = "a"
fun1 3 = "4"
fun1 4 = "3"

But I can't do that:

fun1 1 = "1"
fun1 2 = "a"
fun1 3 = "4"

a = 3 -- Just some code here.

fun1 4 = "3"

ie I need something to remove this restriction.

I need it in some kind of "game", where the previous code can't be edited.

Thank you in advance!

Answer 1

As far as I know, this is not possible. Multiple definitions like this are just syntax sugar over case and thus are not terrifically robust syntactic abstractions. It's just not normally necessary.

You may have luck using the haskell-src package to parse Haskell code and build your incremental interface for your game.

Answer 2

I can't help feeling that if this were allowed, folk would write rather messy code.

Unless there's an important structural reason, it'd be better to stick with the usual valid syntax - it's easier to understand if the definition is all in one place.

However, perhaps it would be better to structure it differently to achieve what you want:

• You could use Data.Map to build up several submaps in different parts of your code, then glue them all together at some appropriate stage.

• You could keep these definitions in a sort of configuration file or files, and read them in as your game initialised. Your users might like the ease of editing the game this way.

• You could store your data in a more Haskell-friendly way

  • You could serialise it using the binary package, which is fast, and read it in at runtime.

  • You could use Yesod's backend-agnostic Persistent

  • Too many other options here

• You could use a union type (like Either ) for your input to fun1 , and then distribute the definition about the code, but write a unified function that checks the input and tags it according to category.

It's hard to know what's best without some knowledge of what you're trying to do, but slackening the sytnax rules doesn't feel like a good step forward.