CPS506 - Comparative Programming Languages - Winter 2022

I think you need to revisit the role of type classes, and try things like :t (==) and :info Eq

p a i r L i s t   : :   ( a−>b )−>( b−>c )−>[ a ]−>[ ( b , c ) ]

It doesn't matter what the parameter functions do, as long as they have the domain and range as specified. Why would you write functions for them? You are asked to write a function that takes parameters of the particular types and return the appropriate result. The fact that you don't know the types of a, b, and c really restricts what code you can write that will match the signature. Apart from gratuitously adding calls to id, or constructing data structures and deconstructing them, there is actually only one function this can possibly be.

    +
|   |   |
1   2   2

For prefix, we will accept either no parentheses (if the arity is correct), or every operator parenthesized (allowing variable arity).

In the example you show, the first one is wrong, because you can't know the arity. The second one is also wrong, although the reverse (+ 1 2 2) is generally how prefix is done. The third one is correct, because + has fixed arity of 2.

Obj.call(p1,{:moveDelta,3,1})

def new(), do: spawn(MODULE,:init,[]).

This is emulating objects with processes. :moveDelta is a symbol (i.e. like a string literal, except more efficient to compare). new just creates an object; init calls new because that's what functional decomposition is! Regardless, we decided that we didn't cover processes completely enough to ask that question.

This is an example of a use of the fold function.... not a definition. You would have to write the actual fold function.

Fossil reports times as UTC (also known as GMT) time. Not to worry.

data Pt = Pt3 Float Float Float
 | Pt2 Float Float deriving (Show)
instance Num Pt where
 (Pt2 x1 y1) + (Pt2 x2 y2) = Pt2 (x1 + x2) (y1 + y2)
 (Pt3 x1 y1 z1) + (Pt3 x2 y2 z2) = Pt3 (x1 + x2) (y1 + y2) (z1 + z2)
 (Pt2 x1 y1) - (Pt2 x2 y2) = Pt2 (x1 - x2) (y1 - y2)
 (Pt3 x1 y1 z1) - (Pt3 x2 y2 z2) = Pt3 (x1 - x2) (y1 - y2) (z1 - z2)
 (Pt2 x1 y1) * (Pt2 x2 y2) = Pt2 (x1 * x2) (y1 * y2)
 (Pt3 x1 y1 z1) * (Pt3 x2 y2 z2) = Pt3 (x1 * x2) (y1 * y2) (z1 * z2)
 abs (Pt2 x y) = Pt2 (abs x) (abs y)
 abs (Pt3 x y z) = Pt3 (abs x) (abs y) (abs z)
 signum (Pt2 x y) = Pt2 (signum x) (signum y)
 signum (Pt3 x y z) = Pt3 (signum x) (signum y) (signum z)
 fromInteger n = let a = (fromInteger n) in Pt2 a a 
 fromInteger n = let a = (fromInteger n) in Pt3 a a a

*Main> :reload
[1 of 1] Compiling Main             ( Foo.hs, interpreted )

Foo.hs:14:2: Warning:
    Pattern match(es) are overlapped
    In an equation for ‘fromInteger’: fromInteger n = ...
Ok, modules loaded: Main.
*Main> (Pt2 1 2) + 4
Pt2 5.0 6.0

The constructors Pt2 and Pt3 both produce the same type, Pt. So the 2 definitions of fromInteger have the same name and same type signature, so they conflict.

This appears to be windows being super-agressive about expiring SSL certificates. I have verified the certificate and it is good until the end of June. Therefore you can simply say "always" accept the certificate, and things should proceed normally.

let mut indices : Vec = cards.map(|card| deck.iter().position(|&r| r == card).unwrap()+1).collect();

No, the specification is the same for all versions of the assignment. Of course you can do whatever you want in your code, such as subtracting 1.

Yes, edit the testing.rs file if you want, but I recommend adding your tests at the bottom or top, rather than intermingled through the file. This will make merging easier for the marker. You could also add a:

mod my_testing;

line to the main.rs file, and then put your tests in the my_testing.rs file (if you do this, don't forget to say fossil add src/my_testing.rs once to tell fossil you care about this file.

Yes, every time you do fossil commit all the files in the working directory that fossil knows about will be sent to the course repository.

Yes, you may add a random number generator crate to the dependencies in the Cargo.toml file. I have added a new item to the A4 web page to clarify this.

Don't worry, your repository hasn't been removed!

One of the reasons we are using fossil is that fossil never deletes anything! Anything! Once your "fossil commit" has shown up on the fossil web page, it's there, until or unless the SCS machine room is destroyed.

What you see is a second "branch" in the repository, a branch called "marking". When you look at the "Files" tab, if you only see the "Marks.txt" file, then it has not yet been marked. If you click on the "trunk" button, you'll see your repo, intact.

When the marker marks the assignment, they will merge the marking branch into the trunk, and update the "Marks.txt" file.

In your working directory, you can move between the branches by saying:

      fossil update marking
    

or

      fossil update trunk
    

"trunk" is the name of the main, published, thread. Branches are usually used for bugfixes or optional features. We're using them to facilitate marking.

Once it's marked, the marking branch will have been merged into the trunk, and all the files will be visible on truck.

As it says somewhere, add to the test file I provided you. Add either at the beginning or the end so that if we add more tests for marking purposes there is less chance of a conflict.

I have updated the assignment definition to make clearer that the with_permutation function should return a "game object" and that the format_game should take a single parameter "game object" and return a string. Where "game object" is (as in the previous assignments) whatever you want it to be, but it's a single value (most likely a struct in Rust, a data type in Haskell, a tuple in Elixir, and an instance of the BidBridge class in Smalltalk).

fossil time -R my_name.fossil

That is because you initially entered a bad password and then when it re-prompted, you entered it correctly. This is a fossil bug and has now been fixed (for those that compile fossil from source) but the download files haven't yet been updated because those versions are only released every few months. Just remove that file that was created and re-clone - should be fine.

Click the login button in the top right. Fossil can allow anonymous cloning of repositories, but I've disabled that for assignments, for obvious reasons. So usually it prompts you to log in, but sometimes (for reasons I don't completely understand) it shows the anonymous result, which is empty for the reason above.

Type:

fossil add Ownership.txt

and then commit.

Read the difference between your 2 paragraphs. The doubleton could be headed by an Ace or a King. If you have 3 cards in a suit, you must have at least a Queen, and so on.

Add them either to the end or the beginning of that test file. Do not create a new test file or remove tests (except that you can/should correct test N3).

No... they can go to the next level, but unless they have 13+ points they won't skip a level. If they had less than 10 points, they cannot, so if Clubs was their best suit, with 11 points they would go to 2C, but with less than 10, they'd simply raise partner (or pass if less than 6).

You're correct. As was posted on D2L, there is an error in the test case N3 as South's best suit is Spades, so the bidding should be:

South West North East
Pass Pass 1D Pass
1S Pass Pass Pass
Declarer: South

Sorry I forgot to say that here, too. Now I have!

A No Trump hand is described in 5.8. It means a balanced hand that will be able to win tricks on the basis of high cards rather than distribution. When to bid is decribed in 5.9.3, 5.11.1, 5.11.2, 5.12.1

Because Clubs are lower than Diamonds, so the lowest possible Club bid, over 1D is 2C. The description said "at the 1 level"; I've corrected it to say "at the lowest possible level (typically 1)".

The bidding is independent in the sense that East, for example, wouldn't take into account the suit that North bid, or the number of points it implies, but every bid must be higher than the previous bid, or Pass. In real bidding this is sometimes used by throwing in a bid purely to push the opponents too high, so they may not have enough bidding room to find their best contract - but this is irrelevant to us.

Because 5.9.2 and 5.9.4 say (indirectly) that you only bid hearts or spades if they are 5 cards or more. This is actually a standard rule in bidding, although the justification is beyond this assignment.

"No Trump" is what it says, there is no trump suit, so high cards matter more. Therefore, to open NT, you need more points, as described in 5.9.3. It is also useful as an answer to say, "I don't have support for your suit, but I have everything else covered, and have a moderately strong hand", as described in 5.11.1 and 5.11.2. It's also usedful (though irrelevant to us) in that a "game" bid in NT is only 9 trick (a bid of 3NT)s, versus 10 in hearts or spades, and 11 in clubs or diamonds.

Has to be. See also the question from 2019.02.27 10:36 below.

One of the real advantages to using a version control system to submit assignments is that you can commit any time you need to. Up to the due time, there will obviously be no penalty. Even if it is after the deadline, because the marker can see what was changed, there may be no penalty if it was a trivial change, and only a minor penalty if it was a small change.

As it says on the midterm page and the D2L announcement, this includes all the questions that might be relevant for the entire course, and some of the questions will only be relevant for the final exam.

   Declarer: None

You would bid 2C. It you didn't have 10 points, then 5.11.3 would apply and then over 1H you could only bid your suit if it was Spades, because anything else would force you to go to the 2 level.

Dr. Mason answers: Mea culpa! You can resolve the first problem by creating a BridgeBid class with a single, class-side, method:

new
    ^ BidBridge new

Code critic will likely give you a warning or two, but you can ignore them
You can resolve the second problem by adding a class-side method to your BidBridge class:

withPermutation: aCollection
    ^ self new withPermutation: aCollection

Smalltalk programmers rarely use Transcript, because there are so many better ways to examine values. The easy way to find out the class of an expression is to inspect it. E.g. (1 to: 52) inspect or simply highlight the 1 to: 52 in any window and type command-i or control-i or type comand-p or control-p to print it. Inspect is used a lot more because you can explore the value.

As to how to work with intervals, they mostly work like collections, so do: collect: select: all work fine. In fact I'm hard pressed to find something you can't do with them, except store into them, and I can't imagine why you'd be wanting to store into the card permutation you are presented with. But, if you do need an Array for some reason, you can get an Array from an Interval called permutation with the expression: permutation collect: #yourself

March 8th, 18:30-20:30, in various rooms in ENG-LG

I would have a Hand class, instances of which hold the cards in a haand, and has methods that do the bidding. printOn: takes a stream and prints the hands and bidding on the stream, using methods like printOn:, nextPut:, and nextPutAll:. There are string streams, and the Transcript stream which outputs into a window. The tests produce a string because that is easiest to compare to.

The method returns a game object that has the deal included, with the bidding done.

You're not the only one! Because the fossil environment setup was delayed we'll accomodate for Assignment 1. I will convert a private fossil into a shared fossil that is done by 2 people. The person whose repository you wish to submit should send an email, CC to the other student, telling me the situation. I will then make that private repository into a shared repository waiting for the second student to agree, and email you both to say that is done. Once that is done the second student's private repository will disappear so make sure you have everything in the first student's repository (verified using the fossil GUI on the account page) before asking me to make it a shared repository.

Go to the account page and click on the "Fossil" button. Log in and if you click on timeline you should see something after dmason's check-in on February 6. If you don't, you have not committed successfully. Most likely you haven't committed at all with fossil. From within Pharo, you can save your package, which will update your Fossil working directory, but until you say fossil ci -m "some reason", it hasn't been saved in the fossil repository. Once you say fossil ci it will commit it to your local repository and then send it to the remote respository, where you can see it by clicking on the "Fossil" button.

If you're working with a partner and they can't see your changes, you are looking at the same problem.

The general principle is "write tests for any non-trivial functionality". Setters and getters (in Smalltalk, methods called abc and abc: not etAbc and setAbc as they might be called in Java) are (generally) trivial functions, so would not have unit tests.

There was a problem when you used certain special characters to get the entropy of your password high enough. Sorry; fixed now!

1.33 is very old! (at least 3.5 years) More importantly, it's incompatible with the 2 series. The current version available to download from https://fossil-scm.org/index.html/uv/download.html is version 2.7. Sometimes other sources are not current - in particular Linux distributions.

Unfortunately, I don't use Windows for anything, so my ability to help is limited, but I will see what I can do.

Yes, it is in KHE127 on Friday, Feb 15, 18:00-20:00 - 2 hours after the regular class which will meet as normal.

Yes, the fossil setup is now working. See the Account link in the navigation box

As the assignment says, "Your BidBridge instance must have a withPermutation: method" and "Your BidBridge instance may have a play: method". Any other classes and methods are up to you. Unit tests should be broken down on a class-by-class basis, so for BidBridge there should be a BidBridgeTest that subclasses TestCase, etc.

The fossil includes quite a few unit tests. You could use Test-Driven-Design to implement the rest of your solution, but you don’t have to keep my tests (you can create your own that use the methods you chose to implement). The only tests that really should produce the correct results are the ones in BridgeBidTest, as they check that the required method produces the correct output.

You are correct. Though still much simpler than a real player would do, they were needlessly complicated. They have been simplified.

This only applies to sections 1,2,6 (although others are welcome to attend). There will be regular class 2-4 on February 15th, and then an additional make-up class (to replace the February 1st class that was cancelled) from 6-8.

No, while bidding, your hands do not change. This means after the cards have been dealt, there will be no further changes to any hand. But this doesn't mean you should "save" the points counts... just recalculate as needed... efficiency is not an issue. (Execution efficiency is much less often an issue in the world than many programmers think!)

Just allow the bidding to continue until there have been 3 consequetive passes (making sure that everybody has had an opportunity to bid at least once!).

I was just told that the ARC building is closed until further notice, so Dr. Mason's class is closed, but he'll be in his office to answer any questions.

Actually, the shuffle is optional. Dealing the cards, printing out the result, bidding, and printing out the bidding are the major components.

They will be on paper. About 1/2 - 2/3 of the marks will be multiple-choice (but about concepts, not memorized definitions). The remainder will be short-answer programming problems - in 2 languages for the midterm, all 4 for the final.

No, you don't need AI. You need to read the whole description. The bidding as described is deterministic (or at least is intended to be, if you discover any ambiguity, please let me know).
I have updated the description to make it clearer, and hopefully made the numbering clearer so you can report any problems.
Also, realize that even if you don't get the bidding, if you get the rest and have good tests, you'll get at least 1/2 the marks, and you'll understand the language significantly better.

Clarified.

Probably this weekend.

There may be fewer than 52 elements in the array (which may be useful for debugging and tests), but all will be in the range 1..52 and unique. You can assume that.